一、线程相关概念

（一）程序、进程和线程的区别

• 程序

程序是含有指令和数据的文件，被存储在磁盘或其他的数据存储设备中，也就是说程序是静态的代码。

• 进程

进程是程序的一次执行过程，是系统运行的基本单位，因此进程是动态的。系统运行一个程序即是一个进程从创建，运行到消亡的过程。简单来说，一个进程就是一个执行中的程序，它在计算机中一个指令接着一个指令地执行着，同时，每个进程还占有某些系统资源如CPU时间，内存空间，文件，文件，输入输出设备的使用权等等。换句话说，当程序在执行时，将会被操作系统载入内存中。

• 线程

线程，与进程相似，但线程是一个比进程更小的执行单位。一个进程在其执行的过程中产生多个线程。与进程不同的是同类的多个线程共享同一块内存空间和一组系统资源，所以系统在产生一个线程，或是在各个线程之间做切换工作时，负担要比进程小得多，线程也被称为轻量级进程。

（二）并行和并发

• 并行：指两个或多个事件在同一时刻发生（同时发生 同时处理 执行者不是一个）。
• 并发：指两个或多个事件在同一个时间段内发生【交替的发生 执行者是一个】。

1、电脑在执行任务时是采用并发还是并行？

使用的是并发，因为电脑上只有一个CP，但是电脑上却可以同时运行多个程序，这是一种假象,因为CPU的计算速度极快，10^-9每秒就会计算一次,而人能感觉到的时间流失是秒，所以电脑给我们一种感觉好像电脑上程序在同时执行。

二、Java实现多线程的三种方式

（一）继承Thread

Thread就是一个线程类，里面定义所有和线程相关的功能，只有是这个类才能开启的任务，才能被CPU单独去执行。

Java中线程执行的时候是采用的并发。学习的过程中不要纠结于多个线程执行的结果，因为是随机在执行，抢占式的在使用CPU资源。

1、方法介绍

2、实现步骤

• 定义一个类MyThread继承Thread类
  • 在MyThread类中重写run（）方法，添加自己的任务
  • 创建MyThread类的对象
  • 启动线程

3、代码示例

package com.why.demo02;// 继承Thread类,MyThread就具备所有和线程相关的功能
public class MyThread extends Thread{
// 重写run方法, 条件自己的任务
@Override
public void run() {// 添加一个任务打印一百次:MyThread线程任务 ----for (int i = 1; i < 101; i++) {System.out.println("MyThread线程任务 ---- " + i);}}
}

package com.ujiuye.demo02;public class UseMyThread {
public static void main(String[] args) {// System.out.println( 1 / 0);// 创建一个MyThread对象MyThread mt = new MyThread();// 调用start方法开启线程mt.start();// mt.run(); 千万不要调用run方法,因为并没有开启线程,只是一个对象调用一次方法而已.// 这个循环属于main方法所在的线程,就是换一个叫做"main"线程,这线程就是主线程for (int i = 0; i < 100; i++) {System.out.println("主线程中的任务---" + i);}}
}

继承开启多线程的简化版：匿名内部类的方式

Thread 变量名 = new Thread() {

        重写run方法;

}

变量名.start();

new Thread() {

        重写run方法;

}.start();

public class UseNoNameClassImpThread {public static void main(String[] args) {// 匿名内部方式继承Thread类开启多线程Thread t = new Thread(){@Overridepublic void run() {for (int i = 0; i < 100; i++) {System.out.println("线程1-----"+i);}}};t.start();new Thread(){@Overridepublic void run() {for (int i = 0; i < 100; i++) {System.out.println("线程2-----"+i);}}}.start();}
}

（二）实现Runnable接口

Runnable是一个接口。仅仅用来描述线程要执行的任务。它的实现类就是线程执行的任务，实现类不是线程对象。

1、方法介绍

解释：

Thread的构造方法创建对象的时候传入了Runnable接口的对象 ，Runnable接口对象重写run方法相当于指定线程任务，创建线程的时候绑定了该线程对象要干的任务。

2、实现步骤

• 定义一个类MyRunnable实现Runnable接口
• 在MyRunnable类中重写run（）方法
• 创建MyRunnable类的对象
• 创建Thread类的对象，把MyRunnable对象作为构造方法的参数
• 启动线程

3、代码示例

package com.offcn.demo2;
// 1.定义一个MyRunnable类实现Runnable接口
public class MyRunnable implements Runnable{// 2.重写接口中的run方法.定义线程任务内容@Overridepublic void run() {for (int i = 1; i < 101; i++) {System.out.println("任务对象----"+i);}}
}

public class UseMyRunnable {public static void main(String[] args) {// 3.创建任务类对象MyRunnable m1 = new MyRunnable();// 4.创建线程对象,把任务对象绑定到线程中Thread t1 = new Thread(m1);t1.start();for (int i = 0; i < 100; i++) {System.out.println("主线程------"+i);}}
}

匿名内部类实现Runnable接口，开启多线程

Runnable r = new Runnable() {

        重写run方法

};

Thread t = new Thread(r);

Thread t2 = new Thread(new Runnable() {

        重写run方法

});

public class NoNameRunnableObject {public static void main(String[] args) {// 匿名内部类为Runnable提供实现类Runnable r = new Runnable() {@Overridepublic void run() {for (int i = 1; i < 20; i++) {System.out.println("任务1-----"+i);}}};// 任务对象绑定到线程对象中,相同的任务可以被多个线程对象执行.// 解开了之前继承实现多线程下任务和线程之间的耦合性.Thread t1 = new Thread(r );Thread t2 = new Thread(r);t1.start();t2.start();Thread t3 = new Thread(new Runnable() {@Overridepublic void run() {for (int i = 1; i < 30; i++) {System.out.println("任务2------我爱学习java");}}});t3.start();}
}

（三）实现Callable接口

这种实现多线程方式类型有三个：Callable接口，FutureTask类，Thread类。

1、方法介绍

FutureTask实现了RunnableFuture接口，而RunnableFuture是Runnable接口子接口，所以FutureTask对象就可以看做一个Runnable接口实现类对象使用，可以通过Thread类的Thread（Runnable target）构造方法，把Ruture Task对象绑定到线程对象中。

2、实现步骤

定义一个类MyCallable实现Callable接口

• 在MyCallable类中重写call（)方法
• 创建MyCallable类的对象
• 创建Future的实现类FutureTask对象，把MyCallable对象作为构造方法的参数
• 创建Thread类的对象，把FutureTask对象作为构造方法的参数
• 启动线程
  • 再调用get方法，就可以获取线程结束之后的结果

3、代码示例

//实现Callable接口
public class MyCallable implements Callable<String> {@Overridepublic String call() throws Exception {// 线程任务for (int i = 1; i < 100; i++) {System.out.println("女神 咱俩交往吧, I love you!!!");}// 女生给你的反馈return "一起去如家";}
}

public class UseMyCallable {public static void main(String[] args) throws ExecutionException, InterruptedException {// 3.MyCallable对象MyCallable mc = new MyCallable();// 4.创建一个FutureTask对象, 把MyCallable绑定到未来任务对象中FutureTask<String> task = new FutureTask<>(mc);// 5.把未来任务对象绑定到Thread类中Thread t = new Thread(task);t.start();for (int i = 0; i < 100; i++) {System.out.println("主线程-女生不要答应");}// 一定要在线程开启之后,在调用get方法,否则线程就没有开启的机会.String result = task.get();System.out.println("女神的反馈:"+result);}
}

（四）三种创建多线程的使用场景

1、继承的方式：适合于这个任务只想被一个线程的对象执行的情况

2、实现Runnable接口方式：适合于一个任务想被多个线程执行的情况

3、实现Callable接口方式：也适合一个任务想被多个线程执行的情况，你还想得倒任务的执行结果

三、线程Thread类常用方法

（一）线程API之线程名称

1、方法介绍

2、代码示例

public class UseThreadName {public static void main(String[] args) {// 线程如果没有指定名称,也有默认名称: Thread-数字 数字从0开始Thread t1 = new Thread();System.out.println(t1.getName());// Thread-0Thread t2 = new Thread();t2.setName("线程2"); // 修改线程名称System.out.println(t2.getName());// 通过构造方法执行线程名称: Thread(Stirng name)Thread t3 = new Thread("线程1");System.out.println(t3.getName());// 通过构造方法执行线程名称: Thread(Runnable r, String name)Thread t4 = new Thread(new Runnable() {@Overridepublic void run() {System.out.println("任务");}}, "线程3");System.out.println(t4.getName());// 获取main方法所在线程对象Thread t = Thread.currentThread();System.out.println(t.getName());// Exception in thread "main" 在一个叫main线程中出现了异常// System.out.println(1 / 0 );}
}

（二）线程API之线程休眠

1、方法介绍

2、代码示例

public class UseThreadSleepMethod {public static void main(String[] args) {// 匿名内部类体现Thread子类Thread t1 = new Thread("线程1"){@Overridepublic void run() {for (int i = 0; i < 10; i++) {try {Thread.sleep(1000); // 只能try..catch处理异常,因为Thread中
run没有异常的声明,子类重写也不能声明异常} catch (InterruptedException e) {e.printStackTrace();}System.out.println(getName()+"----"+i);}}};t1.start();// 匿名内部类提供Runnable的实现类Thread t2 = new Thread(new Runnable() {@Overridepublic void run() {for (int i = 0; i < 5; i++) {try {Thread.sleep(500);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName() + "----"+i);}}}, "线程2");t2.start();}
}

（三）线程API之线程优先级

1、方法介绍

•  设置线程的优先级【线程的执行java遵循抢占式CPU资源机制，不随着人的意志为转移，规律认为决定不了】，表现就是在一段时间内容，前半段时间内高优先级执行次数多，后半段时间低优先级的执行次数多。
• CPU会尽量的在前期执行优先级高的【不是百分百】

2、代码示例

public class UseThreadPriority {public static void main(String[] args) {Thread t1 = new Thread("线程1") {@Overridepublic void run() {for (int i = 1; i <= 50; i++) {System.out.println(getName() + "----" + i);}}};Thread t2 = new Thread("线程2") {@Overridepublic void run() {for (int i = 1; i <= 50; i++) {System.out.println(getName() + "----" + i);}}};// 获取线程对象默认优先级System.out.println(t1.getPriority()); // 5System.out.println(t2.getPriority()); // 5/* // 练习:获取主线程优先级Thread t = Thread.currentThread();System.out.println(t.getName() + "----" + t.getPriority()); // main----5*/// 设置线程优先级 数字必须是[1, 10] 超出范围就会报错t1.setPriority(Thread.MAX_PRIORITY);t2.setPriority(Thread.MIN_PRIORITY);t1.start();t2.start();}
}

（四）线程API之线程礼让

1、方法介绍

2、代码示例

public class YieldMethod {
public static void main(String[] args) {Thread t1 = new Thread("任务1") {@Overridepublic void run() {for (int i = 0; i < 50; i++) {// 任务1碰到偶数就礼让if(i % 2 == 0) {Thread.yield();}System.out.println(getName()+"------" + i);}}};Thread t2 = new Thread("任务2") {@Overridepublic void run() {for (int i = 0; i < 50; i++) {System.out.println(getName()+"------" + i);}}};// t1和t2的优先级一样,都是5,能触发yield方法.t1.start();t2.start();}
}

基本都是t2先执行完，t1才会执行完。因为t1经常让步。

（五）线程API之线程中断

线程中断方法不是把任务执行中断掉，而是终端的线程状态。

1、方法介绍

2、代码示例

public class UseThreadInterrupt {public static void main(String[] args) {Thread t1 = new Thread("why"){@Overridepublic void run() {try {Thread.sleep(5000);} catch (InterruptedException e) {e.printStackTrace();}for (int i = 1; i <= 5; i++) {System.out.println(getName()+"i");}}};t1.start();t1.interrupt(); // 看到程序执行的之后,就不回你再停留5秒才走循环体. 线程状态被中断会异常,但是咱们使用try...catch处理异常,程序出了异常还能继续执行.}
}

（六）线程API之后台线程

1、方法介绍

2、代码示例

public class UseThreadDaemon {public static void main(String[] args) {Thread t = Thread.currentThread();boolean daemon = t.isDaemon();System.out.println(daemon ? "主线是守护线程" : "主线程不是守护线程");// 自己创建的线程对象,默认都不是守护线程.Thread t1 = new Thread("大王"){@Overridepublic void run() {for (int i = 0; i < 100; i++) {System.out.println("我是大王我怕谁???");}}};System.out.println(t1.isDaemon());Thread t2 = new Thread("奴隶"){@Overridepublic void run() {while (true){System.out.println("我是守护者,要为大王服务....");}}};t2.setDaemon(true); // t2就变为守护线程了,就具备守护线程特点, 非守护线程任务结束了,// 那么这个守护线程过一会也会挂掉.System.out.println(t2.isDaemon());t1.start();t2.start();}
}

四、线程安全问题

（一）问题描述

1、买票案例

案例需求:

        某电影院目前正在上映国产大片:一路向西，共有100张票，而它有3个窗口卖票，请设计一个程序模拟该电影院卖票

实现步骤:

        - 定义一个类SellTicket实现Runnable接口，里面定义一个成员变量：private int tickets = 100;

        - 在SellTicket类中重写run()方法实现卖票，代码步骤如下

        - 判断票数大于0，就卖票，并告知是哪个窗口卖的

        - 卖了票之后，总票数要减1

        - 票卖没了，线程停止

        - 定义一个测试类SellTicketDemo，里面有main方法，代码步骤如下

        - 创建SellTicket类的对象

        - 创建三个Thread类的对象，把SellTicket对象作为构造方法的参数，并给出对应的窗口名称

        - 启动线程

2、代码示例

public class SellTicket implements Runnable {// 定义变量模拟要卖的100张票private int ticket = 100;@Overridepublic void run() {while (ticket > 0) {// 卖出一张票数-1ticket--;System.out.println(Thread.currentThread().getName()+"---卖出的是第"+(ticket+1)+"张, 剩余"+ticket+"张");}}
}// 线程安全问题演示
public class ThreadSafeProblem {public static void main(String[] args) {// 卖票任务SellTicket st = new SellTicket();// 创建3个线程对象,模拟三个窗口Thread t1 = new Thread(st, "窗口1");Thread t2 = new Thread(st, "窗口2");Thread t3 = new Thread(st, "窗口3");t1.start();t2.start();t3.start();}
}

3、出现问题

 买票出现的问题：

1. 相同的票出现了多次
2. 出现了负数的票

问题产生的原因：线程执行的随机性导致的，可能再卖票过程中丢失cpu的执行权，导致出现问题。

（二）解决方案

原子操作

处理方案：

1. 同步代码块
2. 同步方法
3. Lock接口（锁对象）

1、同步代码块

（1）格式

synchronized(锁对象) {

        原子操作的代码;【有可能出现线程安全问题的代码】

}

（2）说明

1.  synchronized 同步的意思
2. 锁对象可以是任何引用类型的java对象,只要是一个java对象就可以当做锁对象
3. 锁对象一旦被确定下来要保证唯一性, 锁对象只能有一份

（3）同步代码块执行原理

一段代码一旦使用同步代码块之后，线程只要进入同步代码块，就要先获取锁对象，只有拿到锁对象才能进入同步代码块执行任务，在这个线程执行任务期间，CPU可能会把资源切换到其他线程，即使其他线程也要进入这个同步代码块，因为锁对象已经被之前的线程拿走了，它没有锁对象，依然进不来，只能等之前线程执行完，把锁对象归还，其他线程才有机会拿到锁对象，执行里面任务。

（4）优缺点

优点：解决了多线程的数据安全问题

缺点：当线程很多时，因为每个线程都会去判断同步上的锁。这是很耗费资源的，无形中会降低程序的运行效率。

（5）代码示例

public class SellTicket implements Runnable {// 定义变量模拟要卖的100张票private int ticket = 100;private StringBuilder sb = new StringBuilder();@Overridepublic void run() {while (ticket > 0) { // "a"首先是String对象. 且常量字符串只会在方法区常量池中存储一份.// synchronized (new String("a")) { // 这种锁是锁不住的,每次获取锁对象都new一个新的对象.无法同步代码中原子性操作.// synchronized (this) { // 外面只创建一个SellTicket对象, 且三个线程绑定的都是这个SellTicket对象. 因此this就只代表外界创建这个st对象. 此时依然能保证锁对象的唯一.// synchronized (sb) { sb是SellTicket的一个对象属性,SellTicket在外界只创建了一个st对象,这个st对象sb属性也就只有一个.所以能保证锁对象的唯一.synchronized (SellTicket.class) { // 类名.class就是获取这个类在方法区中加载字节文件之后形成字节码文件对象.一个类字节文件只会在方法区中加载一次.这个类字节文件对象只有一个.它也能充当锁对象if (ticket > 0 ){ // 防止当ticket等于1的时候, 三条线程执行时都满足循环判断// ticket>0成立,进入循环体. 执行同步代码快操作时出现卖负票的情况// 卖出一张票数-1ticket--;System.out.println(Thread.currentThread().getName() + "---卖出的是第" +(ticket + 1) + "张, 剩余" + ticket + "张");}}}}
}// 线程安全问题演示
public class ThreadSafeProblem {public static void main(String[] args) {// 卖票任务SellTicket st = new SellTicket();// 创建3个线程对象,模拟三个窗口Thread t1 = new Thread(st, "窗口1");Thread t2 = new Thread(st, "窗口2");Thread t3 = new Thread(st, "窗口3");t1.start();t2.start();t3.start();}
}

2、同步方法

（1）同步成员方法

格式：

修饰符 synchronized 返回值类型 方法名 ( 方法参数 ) {

        方法体；

}

什么时候使用同步成员方法？

修饰符 返回值类型 方法名 ( 方法参数 ) {

        synchronized ( this ) {

                方法体；

        }

}

因为同步成员方法默认的锁对象就是：this

案例代码：

public class SellTicket implements Runnable {// 定义变量模拟要卖的100张票private int ticket = 100;@Overridepublic void run() {while (ticket > 0) {sell();}
}// 把卖票的过程抽取出来定义到一个成员方法中
// 咱们写的一个成员方法sell,这个方法内部所有的代码都使用同步代码块给包裹了,并且使用的锁对象是this的时候
// 这种写法可以使用同步成员方法简化
/* public void sell() {
synchronized (this) { // this-->st
if (ticket > 0 ){
ticket--;
System.out.println(Thread.currentThread().getName() + "---卖出的是第" +
(ticket + 1) + "张, 剩余" + ticket + "张");
}
}
}*/// 这就是同步方法. 同步成员方法的锁对象就是this. 简化的就是上面sell中的代码
public synchronized void sell() {if (ticket > 0 ){ticket--;System.out.println(Thread.currentThread().getName() + "---卖出的是第" + (ticket + 1) + "张, 剩余" + ticket + "张");}}
}public class ThreadSafeProblem {public static void main(String[] args) {// 卖票任务SellTicket st = new SellTicket();// 创建3个线程对象,模拟三个窗口Thread t1 = new Thread(st, "窗口1");Thread t2 = new Thread(st, "窗口2");Thread t3 = new Thread(st, "窗口3");t1.start();t2.start();t3.start();}
}

（2）同步静态方法

格式：

修饰符 static synchronized 返回值类型 方法名 ( 方法参数 ) {

        方法体；

}

什么时候使用同步静态方法？

修饰符 static 返回值类型 方法名 ( 方法参数 ) {

        synchronized ( 类名 . class ) {

                方法体；

        }

}

因为同步静态方法默认值的锁对象就是：当前类的类对象，类名.class

案例代码：

public class SellTicket implements Runnable {// 定义变量模拟要卖的100张票private static int ticket = 100;@Overridepublic void run() {while (ticket > 0) {sell();}
}// 定义一个静态方法sell,里面所有的代码都使用同步代码块包裹.并且使用的锁对象是当前类字节码文件对象(当前类的类对象)
/* public static void sell() {
synchronized (SellTicket.class) {
if (ticket > 0 ){
ticket--;
System.out.println(Thread.currentThread().getName() + "---卖出的是第" +
(ticket + 1) + "张, 剩余" + ticket + "张");
}
}
}*/// 同步静态方法. 默认使用锁对象就是当前类的类对象(SellTicket.class),简化的就是上面sell方法的写法public static synchronized void sell() {if (ticket > 0) {ticket--;System.out.println(Thread.currentThread().getName() + "---卖出的是第" + (ticket + 1) + "张, 剩余" + ticket + "张");}}
}public class UseSellTicket {public static void main(String[] args) {// 创建卖票的任务SellTicket st = new SellTicket();// 把任务绑定到三个卖票窗口上, 也就三个窗口共同完成一个任务Thread t1 = new Thread(st, "窗口1");Thread t2 = new Thread(st, "窗口2");Thread t3 = new Thread(st, "窗口3");t1.start();t2.start();t3.start();}
}

（3）两种同步方法的锁对象

• 成员同步方法的锁对象是：this
• 静态同步方法的锁对象是：类名.class

3、Lock锁

（1）概述

虽然我们可以理解同步代码块和同步方法的锁对象问题，但是我们并没有直接看到在哪里加上了锁，在哪里释放了锁，为了更清晰的表达如何加锁和释放锁，JDK5以后提供了一个新的锁对象Lock，Lock是接口不能直接实例化，这里采用它的实现类ReentrantLock来实例化。

（2）使用方法

ReentrantLock构造方法

加锁解锁方法

代码示例

public class SellTicket implements Runnable {// 定义变量模拟要卖的100张票private int ticket = 100;// 创建一个锁对象属性private ReentrantLock l = new ReentrantLock();@Overridepublic void run() {while (ticket > 0) {l.lock(); // 获取锁对象if (ticket > 0) {ticket--;System.out.println(Thread.currentThread().getName() + "---卖出的是第" +(ticket + 1) + "张, 剩余" + ticket + "张");}l.unlock();}}
}// 线程安全问题演示
public class ThreadSafe {public static void main(String[] args) {// 卖票任务SellTicket st = new SellTicket();// 创建3个线程对象,模拟三个窗口Thread t1 = new Thread(st, "窗口1");Thread t2 = new Thread(st, "窗口2");Thread t3 = new Thread(st, "窗口3");t1.start();t2.start();t3.start();}
}

总结

无论使用哪种解决方案，原理都是要线程同步，要报原子性操作代码块的完整性，不能中途被打断，加锁同步。

加锁原则：保证锁唯一

五、死锁

（一）死锁的概述和现象演示

1、概述

线程死锁是指由于两个或者多个线程相互持有对方所需要的锁资源，导致这些线程处于等待状态，无法继续执行。

2、图示

3、代码示例

public class DeadLock {
// 两个锁对象
private static final String l1 = "A";
private static final String l2 = "B";public static void main(String[] args) {Thread t1 = new Thread("线程1") {@Overridepublic void run() {synchronized (l1) {try {Thread.sleep(20); // 休眠是为了放大死锁现象出现的概率,让t1和t2更容易交替执行} catch (InterruptedException e) {e.printStackTrace();}synchronized (l2) {System.out.println("任务1");}}}};Thread t2 = new Thread("线程2") {@Overridepublic void run() {synchronized (l2) {try {Thread.sleep(20);} catch (InterruptedException e) {e.printStackTrace();}synchronized (l1) {System.out.println("任务2");}}}};t1.start();t2.start();}
}

（二）死锁诊断

六、线程状态

1、概述

线程生命周期，线程对象从生到死一个过程，当线程被创建并启动以后，他既不是一启动就进入了执行状态，也不是一直处于执行状态。线程对象在不同的时期有不同的状态。

2、线程状态图示

通过java代码的方式。获取实际中线程在程序中会出现的各种状态。在Thread类中提供有一个方法：getState（）。此方法就可以返回线程对象状态。 

七、线程池

（一）线程池概述

1、线程池存在的意义：

• 系统创建一个线程的成本是比较高的，因为它涉及到与操作系统交互，当程序中需要创建大量生存期很短暂的线程时，频繁的创建和销毁线程对系统的资源消耗有可能大于业务处理是对系统的消耗。
• 系统资源的消耗很多,大于任务消耗的资源，这样就有点"舍本逐末"了。针对这一种情况，为了提高性能，我们就可以采用线程池。线程池在启动的时，会创建大量空闲线程，当我们向线程池提交任务的时，线程池就会找到一个空闲线程来执行该任务。等待任务执行完毕以后，线程并不会死亡，而是再次放回到线程池中称为空闲状态。等待下一次任务的执行。这样就可以达到对线程对象重复利用的效果。

2、线程池缺点

（二）Executors获取线程池

1、概述

2、理解

3、ExecutorService

public static void reuseThread() {// Executors是java提供一个工具类,通过该类就可以获取java中给我们准备一些// 不同作用和特点线程池对象.// 获取一个能缓存线程对象的线程池.ExecutorService pool = Executors.newCachedThreadPool();for (int i = 1; i <= 100; i++) {// Runnable的run方法中的内容将来要在别的线程中执行.变量i是在主线程中定义的.变量的使用是不能夸线程的.// 之所不让跨线程使用的原因.多个线程操作同一个数据有安全隐患.final int j = i;Runnable r = new Runnable() {@Overridepublic void run() {System.out.println(Thread.currentThread().getName()+"----任务"+j);}};pool.submit(r);}
}public static void simpleThreadPool1() {// 获取一个能缓存线程对象的线程池.ExecutorService pool = Executors.newCachedThreadPool();// 准备三个任务Runnable r1 = new Runnable() {@Overridepublic void run() {System.out.println(Thread.currentThread().getName()+"----任务1"); // pool-1-thread-1----任务1}};Runnable r2 = new Runnable() {@Overridepublic void run() {System.out.println(Thread.currentThread().getName()+"----任务2"); // pool-1-thread-2----任务2}};Runnable r3 = new Runnable() {@Overridepublic void run() {System.out.println(Thread.currentThread().getName()+"----任务3"); // pool-1-thread-3----任务3}};// 任务提交到线程池pool.submit(r1);pool.submit(r2);pool.submit(r3);// 线程池不关闭程序不会停止.
}

public static void useNewFixedThreadPool() {// Executors是java提供一个工具类,通过该类就可以获取java中给我们准备一些// 不同作用和特点线程池对象.// 获取一个能缓存线程对象的线程池.ExecutorService pool = Executors.newFixedThreadPool(3);Runnable r1 = new Runnable() {@Overridepublic void run() {System.out.println(Thread.currentThread().getName()+"----任务1");}};Runnable r2 = new Runnable() {@Overridepublic void run() {System.out.println(Thread.currentThread().getName()+"----任务2");}};Runnable r3 = new Runnable() {@Overridepublic void run() {System.out.println(Thread.currentThread().getName()+"----任务3");}};Runnable r4 = new Runnable() {@Overridepublic void run() {System.out.println(Thread.currentThread().getName()+"----任务4");}};pool.submit(r1);pool.submit(r2);pool.submit(r3);pool.submit(r4);
}

public static void useNewSingleThreadExector() {// 获取只有一个线程对象线程池ExecutorService pool = Executors.newSingleThreadExecutor();Runnable r1 = new Runnable() {@Overridepublic void run() {System.out.println(Thread.currentThread().getName()+"----任务1");}};Runnable r2 = new Runnable() {@Overridepublic void run() {System.out.println(Thread.currentThread().getName()+"----任务2");}};pool.submit(r1);pool.submit(r2);
}