Java基础-进程与线程之Thread类详解

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　作者：尹正杰

一.进程与线程的区别

　　简而言之：一个程序运行后至少有一个进程，一个进程中可以包含多个线程。线程是程序执行任务的最小单位。

1>.进程的概念：

　　进程指正在运行的程序。确切的来说，当一个程序进入内存运行，即变成一个进程，进程是处于运行过程中的程序，并且具有一定独立功能。

2>.线程的概念：

　　线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。

二.程序运行原理

1>.分时调度

　　所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间。

2>.抢占式调度

　　优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)，Java使用的为抢占式调度。

三.Thread类介绍

　　该如何创建线程呢？通过API中搜索，查到Thread类。通过阅读Thread类中的描述。Thread是程序中的执行线程。Java 虚拟机允许应用程序并发地运行多个执行线程。

继续阅读，发现创建新执行线程有两种方法。

　　1>.一种方法是将类声明为 Thread 的子类。该子类应重写 Thread 类的 run 方法。创建对象，开启线程。run方法相当于其他线程的main方法。

　　2>.另一种方法是声明一个实现 Runnable 接口的类。该类然后实现 run 方法。然后创建Runnable的子类对象，传入到某个线程的构造方法中，开启线程。

　　其实，还有第三种创建线程的方式，就是通过线程池的方式(实现Callable接口方式)，本篇博客会有相应的案例。

四.实现线程程序继承Thread

1>.线程执行的随机性

　　创建线程的步骤：　　

　　　　a>.定义一个类基础Thread；

　　　　b>.重写run方法；

　　　　c>.创建子类对象，就是创建线程对象；

　　　　d>.调用start方法，开启线程并让线程执行，同时还会告诉JVM去调用run方法；

 1 /*
 2 @author :yinzhengjie
 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 4 EMAIL:y1053419035@qq.com
 5 */
 6 
 7 package cn.org.yinzhengjie.note;
 8 
 9 public class MyThread extends Thread{
10     @Override
11     public void run() {
12         for(int i = 0; i < 5 ;i++) {
13             System.out.println("Run..."+i);
14         }
15     }
16 }

MyThread.java 文件内容

 1 /*
 2 @author :yinzhengjie
 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 4 EMAIL:y1053419035@qq.com
 5 */
 6 
 7 package cn.org.yinzhengjie.note;
 8 
 9 public class ThreadDemo {
10     public static void main(String[] args) {
11         MyThread t = new MyThread();
12         //多次启动一个线程是非法的。特别是当线程已经结束执行后，不能在重新启动。
13         t.start();
14         for(int i = 0; i < 5 ;i++) {
15             System.out.println("Main..."+i);
16         }
17     }
18 }
19 
20 /*
21 以上代码执行结果如下：
22 Main...0
23 Run...0
24 Main...1
25 Run...1
26 Main...2
27 Run...2
28 Main...3
29 Run...3
30 Main...4
31 Run...4
32 */

2>.线程对象调用 run方法和调用start方法区别？

　　答：线程对象调用run方法不开启线程。仅是对象调用方法。线程对象调用start开启线程，并让jvm调用run方法在开启的线程中执行。

3>.为什么要继承Thread,并调用其的start方法才能开启线程呢？

　　答：继承Thread类：因为Thread类用来描述线程，具备线程应该有功能。

4>.为什么不直接创建Thread类的对象呢？

　　答：直接创建Thread类的对象并没有太大的意义，因为创建Thread类并调用其start方法，可以开启一个新的线程并调用Thread类中的run方法，而这个run方法没有做任何事情。更重要的是这个run方法中并没有定义为我们需要让线程执行的代码。（这个可以参考Thread源码的run方法！）

5>.为什么要创建线程

　　答：是为了建立程序单独的执行路径，让多部分代码实现同时执行。也就是说线程创建并执行需要给定线程要执行的任务。对于之前所讲的主线程，它的任务定义在main函数中。自定义线程需要执行的任务都定义在run方法中。

6>.为什么要重写run方法

　　答：Thread类run方法中的任务并不是我们所需要的，只有重写这个run方法。既然Thread类已经定义了线程任务的编写位置（run方法），那么只要在编写位置（run方法）中定义任务代码即可。所以进行了重写run方法动作。

7>.为什么线程执行是具有随机性？

　　答：多线程执行时，到底在内存中是如何运行的呢？以上个程序为例，进行图解说明：多线程执行时，在栈内存中，其实每一个执行线程都有一片自己所属的栈内存空间。进行方法的压栈和弹栈。以上个程序为例，进行图解说明：

五.Thread类常用方法

1>.getName方法【获取当前线程对象的名称】

 1 /*
 2 @author :yinzhengjie
 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 4 EMAIL:y1053419035@qq.com
 5 */
 6 
 7 package cn.org.yinzhengjie.note;
 8 
 9 public class ThreadDemo {
10     public static void main(String[] args) {
11         Thread t = new Thread();
12         String ThreadName = t.getName();
13         System.out.println(ThreadName);
14     }
15 }
16 
17 /*
18 以上代码执行结果如下：
19 Thread-0
20 */

2>.currentThread方法【获取当前线程对象】

 1 /*
 2 @author :yinzhengjie
 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 4 EMAIL:y1053419035@qq.com
 5 */
 6 
 7 package cn.org.yinzhengjie.note;
 8 
 9 public class ThreadDemo {
10     public static void main(String[] args) {
11         //获取当前线程对象
12         Thread thread = Thread.currentThread();
13         //获取当前线程对象的名称
14         String name = thread.getName();
15         System.out.println(name);
16     }
17 }
18 
19 /*
20 以上代码执行结果如下：
21 main
22 */

3>.setName方法【设置当前线程的名称】

 1 /*
 2 @author :yinzhengjie
 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 4 EMAIL:y1053419035@qq.com
 5 */
 6 
 7 package cn.org.yinzhengjie.note;
 8 
 9 public class ThreadDemo {
10     public static void main(String[] args) {
11         //获取当前线程对象
12         Thread thread = Thread.currentThread();
13         //设置当前的线程名称
14         thread.setName("yinzhengjie");
15         System.out.println(thread.getName());
16     }
17 }
18 
19 /*
20 以上代码执行结果如下：
21 yinzhengjie
22 */

4>.sleep方法【在指定的毫秒数内荣当前正在执行的线程休眠（暂停执行）】

 1 /*
 2 @author :yinzhengjie
 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 4 EMAIL:y1053419035@qq.com
 5 */
 6 
 7 package cn.org.yinzhengjie.note;
 8 
 9 
10 
11 
12 public class ThreadDemo {
13     public static void main(String[] args) {
14         for (int i = 0; i < 3; i++) {
15             try {
16                 //先当前线程休息1000毫秒，也就是我们所说的一秒
17                 Thread.sleep(1000);
18                 System.out.printf("还有【%d】秒结束进程\n",3-i);
19             } catch (InterruptedException e) {
20                 e.printStackTrace();
21             }
22         }
23     }
24 }
25 
26 /*
27 以上代码执行结果如下：
28 还有【3】秒结束进程
29 还有【2】秒结束进程
30 还有【1】秒结束进程
31 */

5>.setPriority与getPriority方法【设置和获取当前线程的优先级，优先级越高，枪战CPU执行权限的机会就越大】

 1 /*
 2 @author :yinzhengjie
 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 4 EMAIL:y1053419035@qq.com
 5 */
 6 
 7 package cn.org.yinzhengjie.note2;
 8 
 9 /*
10  * 创建线程第一种方式:
11  *     1.自定义类继承Thread类
12  *     2.重写其中的run方法
13  *     3.创建自定义类的对象,调用它的start方法启动线程
14  */
15 public class MyThread extends Thread {
16     // 构造方法对成员变量赋值
17     public MyThread(String name,int x) {
18         super(name);
19         this.x = x;
20     }
21 
22     public MyThread() {
23     }
24     
25     int x = 0;
26     
27     @Override
28     public void run() {
29         if(x == 1){
30             for (int i = 0; i < 100; i++) {
31                 System.out.println(this.getName() + " 尹正杰 " + i);
32             }
33         }else if(x == 2){
34             for (int i = 0; i < 100; i++) {
35                 System.out.println(this.getName() + " yinzhengjie " + i);
36             }
37         }
38         
39     }
40 
41 }

MyThread.java 文件内容

 1 /*
 2 @author :yinzhengjie
 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 4 EMAIL:y1053419035@qq.com
 5 */
 6 package cn.org.yinzhengjie.note2;
 7 
 8 public class MyThreadDemo {
 9     public static void main(String[] args) {
10         // 创建自定义类对象
11         MyThread mt1 = new MyThread("线程1", 1);
12         MyThread mt2 = new MyThread("线程2", 2);
13         //修改线程1和线程2的优先级。默认有限级取决于创建该线程的父线程，优先级的范围:1-10
14         mt1.setPriority(Thread.MAX_PRIORITY);
15         mt2.setPriority(Thread.MIN_PRIORITY);
16         //获取线程设置的优先级
17 //        System.out.println(mt1.getPriority());
18 //        System.out.println(mt2.getPriority());
19         
20         //尽管咱们先启动线程2，由于上面我们把线程2的优先级设置的最小，因此线程1抢到CPU的概率还是较大的
21         mt2.start();
22         mt1.start();
23     }
24 }

6>.join方法【直到调用该方法的线程执行结束，程序才会再往下执行】

 1 /*
 2 @author :yinzhengjie
 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 4 EMAIL:y1053419035@qq.com
 5 */
 6 
 7 package cn.org.yinzhengjie.note2;
 8 
 9 public class MyThread extends Thread {
10     @Override
11     public void run() {
12         for(int i = 0;i<100;i++){
13             System.out.println(getName() + "hello" + i);
14         }
15     }
16 
17 }

MyThread.java 文件内容

 1 /*
 2 @author :yinzhengjie
 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 4 EMAIL:y1053419035@qq.com
 5 */
 6 package cn.org.yinzhengjie.note2;
 7 
 8 public class MyThreadDemo {
 9     public static void main(String[] args) {
10         MyThread mt1 = new MyThread();
11         MyThread mt2 = new MyThread();
12         mt1.setName("Father");
13         mt2.setName("Son");
14         mt1.start();
15         //让mt1先执行完,再执行当前线程
16         try {
17             mt1.join();
18         } catch (InterruptedException e) {
19             e.printStackTrace();
20         }
21         mt2.start();    //注意，上面的程序执行完毕后，剩下的执行顺序就是mt2线程和main线程互相抢夺CPU啦！
22         for(int i = 0;i<100;i++){
23             System.out.println(Thread.currentThread().getName() + i);
24         }
25     }
26 }

7>.yield方法【暂停当前正在执行的线程对象，并执行其它线程，很有可能当前线程会再次抢到执行权哟！】

 1 /*
 2 @author :yinzhengjie
 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 4 EMAIL:y1053419035@qq.com
 5 */
 6 
 7 package cn.org.yinzhengjie.note2;
 8 
 9 public class MyThread extends Thread {
10     private int num;
11     
12     public MyThread(String name,int num) {
13         super(name);
14         this.num = num * 1000;
15     }
16 
17     public MyThread() {
18         super();
19     }
20     
21     @Override
22     public void run() {
23         for (int i = 0; i < 10; i++) {
24             System.out.printf("%s 第【%d】次执行！\r\n ",this.getName(),i);
25             try {
26                 //暂停当前正在执行的线程对象，并执行其它线程。
27                 Thread.yield();
28                 Thread.sleep(this.num);
29                 
30             } catch (InterruptedException e) {
31                 e.printStackTrace();
32             }
33         }
34     }
35 }

MyThread.java 文件内容

 1 /*
 2 @author :yinzhengjie
 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 4 EMAIL:y1053419035@qq.com
 5 */
 6 package cn.org.yinzhengjie.note2;
 7 
 8 public class MyThreadDemo {
 9     public static void main(String[] args) {
10         MyThread mt1 = new MyThread("线程1",1);
11         MyThread mt2 = new MyThread("线程2",5);
12         mt1.start();
13         mt2.start();
14     }
15 }

8>.deamon方法【也称为守护线程，守候线程在非守候线程结束后，就结束了】

 1 /*
 2 @author :yinzhengjie
 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 4 EMAIL:y1053419035@qq.com
 5 */
 6 
 7 package cn.org.yinzhengjie.note2;
 8 
 9 public class Boss  extends Thread{
10     @Override
11     public void run() {
12         for (int i = 0; i <100; i++) {
13             System.out.println(this.getName() + "==" +  i);
14         }
15     }
16 }

Boss.java 文件内容

 1 /*
 2 @author :yinzhengjie
 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 4 EMAIL:y1053419035@qq.com
 5 */
 6 package cn.org.yinzhengjie.note2;
 7 
 8 public class Worker extends Thread{
 9     @Override
10     public void run() {
11         for (int i = 0; i < 100000; i++) {
12             System.out.println(this.getName() + "------" + i);
13         }
14     }
15 }

Worker.java 文件内容

 1 /*
 2 @author :yinzhengjie
 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 4 EMAIL:y1053419035@qq.com
 5 */
 6 package cn.org.yinzhengjie.note2;
 7 
 8 public class Demo {
 9     public static void main(String[] args) {
10         Boss boss = new Boss();
11         boss.setName("boss");
12         Worker worker = new Worker();
13         worker.setName("worker");
14         worker.setDaemon(true);
15         boss.start();
16         worker.start();
17     }
18 }

9>.stop与interrupt方法【前者不推荐使用，推荐使用interrupt，可以让当前线程终止】

 1 /*
 2 @author :yinzhengjie
 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 4 EMAIL:y1053419035@qq.com
 5 */
 6 
 7 package cn.org.yinzhengjie.note2;
 8 
 9 public class MyThread extends Thread{
10     @Override
11     public void run() {
12         for(int i = 0;i<3;i++){
13             System.out.println(getName() + "--" + i);
14             try {
15                 Thread.sleep(3);
16             } catch (InterruptedException e) {
17                 System.out.println("子线程被中断了.");
18                 e.printStackTrace();
19             }
20             
21             System.out.println("hello");
22         }
23     }
24 }

MyThread.java 文件内容

 1 /*
 2 @author :yinzhengjie
 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 4 EMAIL:y1053419035@qq.com
 5 */
 6 package cn.org.yinzhengjie.note2;
 7 
 8 /*
 9  * 线程终止:
10  *     主线程睡3秒,之后,把子线程终止
11  * 
12  */
13 public class MyThreadDemo {
14     public static void main(String[] args) {
15         MyThread mt = new MyThread();
16         mt.setName("mt");
17         mt.start();
18 //        for(int i = 0;i<3;i++){
19 //            try {
20 //                Thread.sleep(1000);
21 //            } catch (InterruptedException e) {
22 //                e.printStackTrace();
23 //            }
24 //        }
25         
26         //如果子线程还没有结束,就终止它,那是相当的暴力啊，直接干掉mt这个子进程！
27 //        mt.stop();
28         //推荐使用中断方法，并不会彻底杀死mt进程，而是采用中断方法，然后把异常抛给mt子进程。(mt进程中调用了Thread.sleep方法)
29         mt.interrupt();
30     }
31 }
32 
33 
34 
35 /*
36 以上代码执行结果如下：
37 mt--0
38 子线程被中断了.
39 java.lang.InterruptedException: sleep interrupted
40     at java.base/java.lang.Thread.sleep(Native Method)
41     at cn.org.yinzhengjie.note2.MyThread.run(MyThread.java:15)
42 hello
43 mt--1
44 hello
45 mt--2
46 hello
47 */

六.实现线程的另一种方式实现Runnable接口

1>.创建线程的步骤：

　　a>.定义类实现Runable接口；

　　b>.覆盖接口中的run方法；

　　c>.创建Thread类的对象；

　　d>.将Runable接口的子类对象作为参数传递给Thread类的构造函数；

　　e>.调用Thread类的start方法开启线程；

 1 /*
 2 @author :yinzhengjie
 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 4 EMAIL:y1053419035@qq.com
 5 */
 6 
 7 package cn.org.yinzhengjie.note;
 8 
 9 
10 class SubRunnable implements Runnable{
11 
12     @Override
13     public void run() {
14         Thread.currentThread().setName("yinzhengjie");
15         for (int i = 0; i < 3; i++) {
16             try {
17                 //先当前线程休息1000毫秒，也就是我们所说的一秒
18                 Thread.sleep(1000);
19                 System.out.printf("线程【%s】还有【%d】秒结束进程\n",Thread.currentThread().getName(),3-i);
20             } catch (InterruptedException e) {
21                 e.printStackTrace();
22             }
23         }
24     }
25     
26 }
27 
28 
29 
30 public class RunableDemo {
31     public static void main(String[] args) {
32         //实例化我们自定义实现Runnable接口的方法
33         SubRunnable sr = new SubRunnable();
34         //创建Thread类对象，构造方法中，传递Runnable接口实现类
35         Thread t = new Thread(sr);
36         //调用Thread类方法start()方法
37         t.start();
38         for (int i = 0; i < 3; i++) {
39             try {
40                 //先当前线程休息1000毫秒，也就是我们所说的一秒
41                 Thread.sleep(1000);
42                 System.out.printf("线程【%s】还有【%d】秒结束进程\n",Thread.currentThread().getName(),3-i);
43             } catch (InterruptedException e) {
44                 e.printStackTrace();
45             }
46         }
47     }
48 }
49 
50 
51 
52 /*
53 以上代码执行结果如下：（发现执行结果依然是随机性的）
54 线程【main】还有【3】秒结束进程
55 线程【yinzhengjie】还有【3】秒结束进程
56 线程【main】还有【2】秒结束进程
57 线程【yinzhengjie】还有【2】秒结束进程
58 线程【yinzhengjie】还有【1】秒结束进程
59 线程【main】还有【1】秒结束进程
60 */

2>.为什么需要定一个类去实现Runnable接口呢？

　　答：实现Runnable接口，避免了继承Thread类的单继承局限性。覆盖Runnable接口中的run方法，将线程任务代码定义到run方法中。

3>.继承Thread类和实现Runnable接口有啥区别呢？

　　答：创建Thread类的对象，只有创建Thread类的对象才可以创建线程。线程任务已被封装到Runnable接口的run方法中，而这个run方法所属于Runnable接口的子类对象，所以将这个子类对象作为参数传递给Thread的构造函数，这样，线程对象创建时就可以明确要运行的线程的任务。

4>.实现Runnable的好处

　　a>.实现Runnable接口的方式避免了单继承的局限性(比如：我们在实现一个接口的同时还可以继承其它的类)，所以较为常用。

　　b>.实现Runnable接口的方式更加的符合面向对象，线程分为两部分，一部分线程对象，一部分线程任务。继承Thread类，线程对象和线程任务耦合在一起。一旦创建Thread类的子类对象，既是线程对象，有又有线程任务。

　　c>.实现Runnable接口的方式将线程任务单独分离出来封装成对象，类型就是Runnable接口类型。Runnable接口对线程对象和线程任务进行解耦。

　　d>.实现Runnable接口的方式可以让资源实现共享，也就是有多个线程要操作同一个线程的时候，同一个数据在接口当中是共享的(因为多个线程创建对象时传递的是同一个接口)，而继承Thread的类它们的数据一般都是私有的(此处我们不考虑将成员变量修饰为静态(static)成员的情况)。

　　小提示：我们做程序要做到高内聚，低耦合。高内聚指的是自己的事情自己做，自己能做的事情决不让外人去做；低耦合指的是要尽量降低类与类之间的联系性。而接口的应用恰好可以帮我们完成这些事！

七. 线程的匿名内部类使用

　　使用线程的内匿名内部类方式，可以方便的实现每个线程执行不同的线程任务操作。

1>.匿名内部类继承Thread方法

 1 /*
 2 @author :yinzhengjie
 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 4 EMAIL:y1053419035@qq.com
 5 */
 6 
 7 package cn.org.yinzhengjie.note;
 8 
 9 
10 
11 
12 public class ThreadDemo {
13     public static void main(String[] args) {
14         new Thread() {
15             @Override
16             public void run() {
17                 System.out.println("尹正杰到此一游！");
18             }
19         }.start();
20     }
21 }
22 
23 /*
24 以上代码执行结果如下：
25 尹正杰到此一游！
26 */

2>.匿名内部类实现Runnable接口

 1 /*
 2 @author :yinzhengjie
 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 4 EMAIL:y1053419035@qq.com
 5 */
 6 
 7 package cn.org.yinzhengjie.note;
 8 
 9 
10 
11 
12 public class ThreadDemo {
13     public static void main(String[] args) {
14         //实现Runnable接口
15         Runnable r =  new Runnable() {
16             public void run() {
17                     System.out.println("尹正杰再次到此一游");
18             }
19         };
20         //传递实现Runnable接口对象给Thread的构造方法
21         new Thread(r).start();
22         
23     }
24 }
25 
26 /*
27 以上代码执行结果如下：
28 尹正杰再次到此一游
29 */

3>.匿名内部类实现Runnable接口并传递给匿名的Thread对象

 1 /*
 2 @author :yinzhengjie
 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 4 EMAIL:y1053419035@qq.com
 5 */
 6 
 7 package cn.org.yinzhengjie.note;
 8 
 9 
10 
11 
12 public class ThreadDemo {
13     public static void main(String[] args) {
14         new Thread(new Runnable() {
15             //实现Runnable接口
16             @Override
17             public void run() {
18                 System.out.println("尹正杰又到此一游");
19             }
20         }).start(); //别忘了这里需要调用Thread对象的start方法哟！
21     }
22 }
23 
24 /*
25 以上代码执行结果如下：
26 尹正杰又到此一游
27 */

八.线程的状态图

　　线程的状态我们可以画一张图来帮助记忆：

九.使用线程池方式--Runnable接口

1>. 线程池的原理

　　线程池，其实就是一个容纳多个线程的容器，其中的线程可以反复使用，省去了频繁创建线程对象的操作，无需反复创建线程而消耗过多资源。换句话说，程序一开始的时候，创建多个线程对象并存储到集合中，需要线程的时候就会从这个结合中获取线程出来干活。当该线程干完活之后又会回到定义的结合中继续等待其它任务，并不会死亡，直到程序员手动关闭线程池。

　　在java中，如果每个请求到达就创建一个新线程，开销是相当大的。在实际使用中，创建和销毁线程花费的时间和消耗的系统资源都相当大，甚至可能要比在处理实际的用户请求的时间和资源要多的多。除了创建和销毁线程的开销之外，活动的线程也需要消耗系统资源。如果在一个jvm里创建太多的线程，可能会使系统由于过度消耗内存或“切换过度”而导致系统资源不足。为了防止资源不足，需要采取一些办法来限制任何给定时刻处理的请求数目，尽可能减少创建和销毁线程的次数，特别是一些资源耗费比较大的线程的创建和销毁，尽量利用已有对象来进行服务。

　　线程池主要用来解决线程生命周期开销和资源不足问题。通过对多个任务重复使用线程，线程创建的开销就被分摊到了多个任务上了，而且由于在请求到达时线程已经存在，所以消除了线程创建所带来的延迟。这样，就可以立即为请求服务，使用应用程序响应更快。另外，通过适当的调整线程中的线程数目可以防止出现资源不足的情况。　　

2>.使用线程池中线程对象的步骤

　　通常，线程池都是通过线程池工厂创建，再调用线程池中的方法获取线程，再通过线程去执行任务方法，具体步骤如下：

　　a>.创建线程池对象;

　　b>. 创建Runnable接口子类对象;

　　c>.提交Runnable接口子类对象;

　　d>.关闭线程池;

 1 /*
 2 @author :yinzhengjie
 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 4 EMAIL:y1053419035@qq.com
 5 */
 6 
 7 package cn.org.yinzhengjie.note;
 8 
 9 import java.util.concurrent.ExecutorService;
10 import java.util.concurrent.Executors;
11 
12 class ThreadPoolRunnable implements Runnable{
13     @Override
14     public void run() {
15         Thread t = Thread.currentThread();
16         System.out.println(t.getName()+" 尹正杰到此一游！");
17     }
18 }
19 
20 
21 
22 public class ThreadPoolDemo {
23     public static void main(String[] args) {
24         //调用工厂类的静态方法，创建线程池对象,需要传入一个int型的参数，表示线程池容纳的线程对象个数，我这里传入的是5.
25         //返回的是线程池对象，该对象是一个接口。
26         ExecutorService pool = Executors.newFixedThreadPool(5);
27         //调用接口实现类对象pool中的方法submit提交线程任务，将Runnable接口实现类的对象传递进去即可
28         pool.submit(new ThreadPoolRunnable());
29         pool.submit(new ThreadPoolRunnable());
30         pool.submit(new ThreadPoolRunnable());
31         //销毁线程池,一般情况下我们不会用该方法。
32         pool.shutdown();
33     }
34 }
35 
36 
37 /*
38 以上代码执行结果如下：
39 pool-1-thread-3 尹正杰到此一游！
40 pool-1-thread-1 尹正杰到此一游！
41 pool-1-thread-2 尹正杰到此一游！
42 */

3>.实现线程的Callable接口方式

 1 /*
 2 @author :yinzhengjie
 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 4 EMAIL:y1053419035@qq.com
 5 */
 6 
 7 package cn.org.yinzhengjie.note;
 8 
 9 import java.util.concurrent.Callable;
10 import java.util.concurrent.ExecutionException;
11 import java.util.concurrent.ExecutorService;
12 import java.util.concurrent.Executors;
13 import java.util.concurrent.Future;
14 
15 class GetSumCallable implements Callable<Integer>{
16     private int num;
17     //利用构造方法实现成员变量的传参，从而实现了多线程的异步计算。
18     public GetSumCallable(int num) {
19         this.num = num;
20     }
21     //Callable接口的特点就是有返回值，而且还可以抛异常，弥补了Thread类的run的不足！
22     @Override
23     public Integer call() throws Exception {    
24         int sum = 0;
25         for(int i = 1;i <= num;i++) {
26             sum += i;
27         }
28         return sum;
29     }
30 }
31 
32 public class ThreadPoolDemo {
33     public static void main(String[] args) {
34         //创建线程池对象
35         ExecutorService pool = Executors.newFixedThreadPool(2);
36         //提交线程任务的submit方法返回Future接口的实现类,计算1加到100的和
37         Future<Integer> f1 = pool.submit(new GetSumCallable(100));
38         //提交线程任务，计算1加到2000的和
39         Future<Integer> f2 = pool.submit(new GetSumCallable(2000));
40         try {
41             //将线程的返回值拿过来。
42             System.out.println(f1.get());
43             System.out.println(f2.get());
44         } catch (InterruptedException e) {
45             e.printStackTrace();
46         } catch (ExecutionException e) {
47             e.printStackTrace();
48         }finally {
49             //释放资源，根据你的业务需求
50             pool.shutdown();
51         }
52         
53     }
54 }
55 
56 
57 /*
58 以上代码执行结果如下：
59 5050
60 2001000
61 */

posted @ 2018-05-05 23:48 尹正杰阅读(1758) 评论(0) 编辑收藏举报

刷新页面返回顶部

尹正杰

Java基础-进程与线程之Thread类详解

1>. 线程池的原理

公告