Java必知必会之（四）---多线程全揭秘（上）

本文旨在用最通俗的语言讲述最枯燥的基本知识。

全文提纲：
1.线程是什么？（上）
2.线程和进程的区别和联系（上）
3.建立多线程的方法（上）
4.线程的生命周期（上）
5.线程的控制（上）
6.线程同步（下）
7.线程池（下）
8.ThreadLocal的基本用法（下）
9.线程安全（下）

---

1.线程是什么

线程是进程中的一个执行流程，是被系统独立调度和分派的基本单位。

线程是什么？进程是什么？
这么说可能有点懵逼，举个栗子吧：

A工厂是一个生产汽车的工厂，今天员工张三去送货，员工李四去进货。这里的

1. A工厂是一个进程（固然荒废的没有生命迹象的工厂不能算进程了）
2. 员工张三去送货 是一个线程
3. 员工李四去进货 也是一个线程

从例子能够看出
进程是指运行中的程序（没运行的程序，系统是不会为之分配资源的），每一个进程都有本身独立的内存空间，当一个程序进入内存运行时，程序内部可能包含多个程序执行流，这个程序执行流就是一个线程。

几乎全部操做系统都支持多线程并发，就像咱们平时上班用的电脑，咱们可能习惯打开eclipse写代码，同时打开网易云音乐听课，并且还要打开有道翻译时刻准备着把咱们的中文转成英文…
可见咱们的电脑能够支持多个应用程序同时执行的，但实际上，而对于每一个CPU来讲，它在一个时间点内，只能执行一个程序，也就是一个进程，那为何咱们同时打开这么多程序运行没问题呢？
那是由于现代电脑都不止一个CPU啦。固然这个是一个缘由。
最主要的是由于在程序运行过程当中，CPU在不一样程序之间高速的来回切换执行，所以所谓的“并发执行”实际上并非多个程序在同时执行，而是系统对程序的执行作了调度，让视觉上看起来是同时执行了。
因此线程中的并发：
是指多个进程被CPU快速的轮换执行，而不是同时执行

2. 线程和进程的区别

经过上面的原理讲述已经能看出区别了，最主要有2点

1. 线程做为调度和分配的基本单位，进程做为拥有资源的基本单位
2. 线程是进程中的一个执行流程，一个进程能够包含多个线程

3. 多线程的建立

1. 继承Thread类建立线程：

 1public class ThreadTest  extends Thread {
 2    @Override
 3    public void run() {
 4        // 业务逻辑
 5        super.run();
 6    }
 7
 8    public static void main(String[] args) {
 9        new ThreadTest().run();
10        new ThreadTest().run();
11    }
12}
复制代码

2. 实现Runnable接口

 1public class ThreadTest  implements Runnable {
 2    @Override
 3    public void run() {
 4         //业务逻辑
 5    }
 6
 7    public static void main(String[] args) {
 8        new ThreadTest().run();
 9        new ThreadTest().run();
10    }
11}
复制代码

3. 使用Callable和Future建立

Callable接口是jdk5以后的新接口，它提供了一个call方法做为线程执行体，和thread的run方法相似，可是它的功能更强大：

• 它能够有返回值
• 它能够声明抛出异常
  所以也能够像Runnable同样，建立一个Callable对象做为Thread的target，而实现它的call方法做为执行体.
  同时jdk5提供了Future接口来表明Callable接口里的call方法返回值，并为Future接口提供了一个FutureTask实现类，该实现类实现了Future接口，并实现了Runable接口，它有如下几个方法：

1. boolean cancal(boolean mayInterruptRunning):试图取消该Future里关联的Callable任务
2. V get():返回Callable任务里call()方法的返回值，调用该方法将致使程序阻塞，必须等到子线程结束后才会获得返回值
3. V get(long timeout,TimeUnit unit):
4. boolean isCancel():若是在Callable任务正常完成前被取消，则返回true
5. boolean isDone():若是Callable任务已完成，则返回true

 1public static void main(String[] args) {
 2
 3        //1)建立一个Callable实现类，并实现call方法
 4        //2）用FutrueTask来包装类的实例
 5     FutureTask ft=new FutureTask<>(new Callable<Integer>() {
 6        @Override
 7        public Integer call() throws Exception {
 8            System.out.println("执行了");
 9            try {
10                Thread.sleep(1000*5);
11            } catch (InterruptedException e1) {
12                // TODO Auto-generated catch block
13                e1.printStackTrace();
14            }
15
16            return 12;
17        }
18    });
19     //使用FutureTask对象做为target来建立而且启动线程
20     new Thread(ft).start();
21
22     //阻塞方式获取线程返回值
23     try {
24        System.out.println("返回值："+ft.get());
25    } catch (InterruptedException e) {
26        // TODO Auto-generated catch block
27        e.printStackTrace();
28    } catch (ExecutionException e) {
29        // TODO Auto-generated catch block
30        e.printStackTrace();
31    }
32     //带有超时方式获取线程返回值
33     try {
34        System.out.println("返回值："+ft.get(2,TimeUnit.SECONDS));
35    } catch (InterruptedException | ExecutionException | TimeoutException e) {
36        // TODO Auto-generated catch block
37        e.printStackTrace();
38    }
39
40    }
复制代码

4. 线程的生命周期

线程建立以后，不会当即处于运行状态，根据前面对并发的定义理解：即便他启动了也不会永远都处于运行状态，若是它一直处于运行状态，就会一直占据着CPU资源，线程之间的切换也就无从谈起了。所以，线程是有生命周期的，他的生命周期包括如下几种状态：

1. 新建（NEW）
2. 就绪（Runnable）
3. 运行（Running）
4. 阻塞（Blocked）
5. 死亡（Dead）

1. 新建状态

当在程序中用new建立一个线程以后，它就处于新建状态，此时它和程序中其它对象同样处于初始化状态（分配内存、初始化成员变量）。

2.就绪状态

当程序调用了start方法以后，程序就处于就绪状态，jvm会为它建立方法调用栈和程序计数器，此时的线程状态为可运行状态，并无运行，而是须要线程调度器的调度决定什么时候运行。

3. 运行状态

当就绪的线程得到CPU以后，就会执行线程执行体（run方法），这时候线程就处于了运行状态。

4.阻塞状态

处于运行的状态的线程，除非执行时间很是很是很是短，不然它会由于系统对资源的调度而被中断进入阻塞状态。操做系统大多采用的是抢占式调度策略，在线程得到CPU以后，系统给线程一段时间来处理任务，当到时间以后，系统会强制性剥夺线程所占资源，而分配别的线程，至于分配给谁，这个取决于线程的优先级。

5.死亡状态

处于运行状态的线程，当它主动或者被动结束，线程就处于死亡状态。至于结束的形式，一般有如下几种：

1. 线程执行完成，线程正常结束
2. 线程执行过程当中出现异常或者错误，被动结束
3. 线程主动调用stop方法结束线程

5.线程的控制

Java提供了线程在其生命周期中的一些方法，便于开发者对线程有更好的控制。
主要有如下方法：

1. 等 待：join()
2. 后 台：setDeamon()
3. 睡 眠：sleep()
4. 让 步：yield()
5. 优先级：setPriority()

1.线程等待

当某个线程执行流中调用其余线程的join()方法时，调用线程将被阻塞，知道被join()方法加入的join()线程执行完成为止。

乍一看，怎么也理解不了，这句话，咱们来写一个程序测试一下：

 1public class ThreadTest  extends Thread {
 2    @Override
 3    public void run() {
 4        System.out.println(getName()+"运行...");
 5        for(int i=0;i<5;i++){
 6            System.out.println(getName()+"执行："+i);
 7        }
 8    }
 9    public ThreadTest(String name){
10        super(name);
11    }
12    public static void main(String[] args) {
13        //main方法--主线程
14        //线程1
15        new ThreadTest("子线程1").start();
16        //线程2
17        ThreadTest t2=new ThreadTest("子线程2");
18        t2.start();
19
20        try {
21          t2.join(1000);
22        } catch (InterruptedException e) {
23          e.printStackTrace();
24        }
25        //线程3
26        new ThreadTest("子线程3").start();
27    }
28}
复制代码

看输出结果：

 1子线程1运行...
 2子线程2运行...
 3子线程2执行：0
 4子线程2执行：1
 5子线程2执行：2
 6子线程2执行：3
 7子线程1执行：0
 8子线程2执行：4
 9子线程1执行：1
10子线程1执行：2
11子线程1执行：3
12子线程1执行：4
13子线程3运行...
14子线程3执行：0
15子线程3执行：1
16子线程3执行：2
17子线程3执行：3
18子线程3执行：4
复制代码

能够看到，线程1和2在并发执行着，而线程3则在他们都执行完以后才开始。
由此可知：
join()方法调用以后，后面的线程必须等待前面执行完以后才能执行，而不是并发执行

2.线程转入后台

当线程调用了setDaemon(true)以后，它就转入为后台线程，为前台线程提供服务，而当前台全部线程死亡时，后台线程也会接受到JVM的通知而自动死亡。

1ThreadTest t2=new ThreadTest("子线程2");
2//这是为后台线程，但必须在start前设置，由于前台线程死亡JVM会通知
3//后台线程死亡，但接受指令到响应须要时间。所以要自爱start前就设置
4        t2.setDaemon(true);
5        t2.start();
复制代码

3. 线程睡眠

当须要某个处于运行状态的线程暂停执行而且进入阻塞状态时，调用Thread.sleep既可。

4.线程让步

当须要某个处于运行状态的线程暂停执行而且进入就绪状态，调用
Thread.yield()便可

5.线程优先级

前面说到，系统分配CPU给哪一个线程的执行，取决于线程的优先级，所以每一个线程都有必定的优先级，优先级高的线程会得到更多的执行机会，默认状况下，每一个线程的默认优先级都与建立它的父线程优先级一致。
当咱们须要某个线程或者更多的执行机会时，调用
Thread.currentThread().setPriority(int newPriority);
方法便可，newPriority的范围在1~10。

关于多线程的揭秘，上集都讲到这里，更高级的使用多线程，尽在下集 请关注我哦。

---

以为本文对你有帮助？请分享给更多人

关注「编程无界」，提高装逼技能