新手一枚，Java学习中，把自己学习多线程的知识总结一下，梳理下知识，方便日后查阅，高手莫进。

本文的主要内容：

[1] 实现线程的两种方法 [2] 线程的启动与停止

[3] 线程的互斥 [4] 线程协作

[5] 线程Join [6]Object实现生产者、消费者问题

[7]Lock类实现生产者、消费者问题 [8] 线程优先级

[9]守护线程（daemon线程） [10]线程池概念

一实现线程的两种方法

JAVA中实现线程，有两种方法。一种是扩展 Threaad 类，一种是实现package java.lang.Runnble接口。

首先来看看这JAVA API文档中如何定义这两个：

Runnble接口

package java.lang;
public interface Runnable {
public abstract void run();
}

这个接口的定义很简单，只是定义了一个方法。

Threaad 类

package java.lang;
public
class Thread implements Runnable {
/* What will be run. */
    private Runnable target;
 private void init(ThreadGroup g, Runnable target, String name,
                      long stackSize, AccessControlContext acc) {
    .........
        this.target = target;
    ........ 
    }
 public Thread(Runnable target) {
        init(null, target, "Thread-" + nextThreadNum(), 0);
    }
 public synchronized void start() {
    ........
}

    @Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }

　　可以看出，Thread 也是实现了Runnable接口，用start()方法启动Therad（）对象时，调用实现Runnable接口所实现的run（）方法。

这个弄明白了，关于线程的启动与停止就很容易搞明白了。

二、线程的启动与停止

（1）启动一个线程必须调用Thread的start（）方法，如果线程类继承Thread，则可以直接调用对象的start（）方法启动，如果线程类实现的是Runnable接口，则需要将对象封装成Thread，再调用封装后对象的start（）；

（2）JAVA只允许单继承，因此当一个类继承另一个类，又想成为一个线程时，就不能继承Thread类了，只能通过实现Runnable接口来实现。

(3)线程的停止方法有

[1] 让线程的run()方法执行完，线程自然结束。（这种方法最好）

[2]通过轮询和共享标志位的方法来结束线程，例如while(flag){},flag的初始值设为真，当需要结束时，将flag的值设为false。（这种方法也不很　　　好，因为如果while(flag){}方法阻塞了，则flag会失效）

[3]使用interrupt()，而程序会丢出InterruptedException例外，因而使得执行绪离开run()方法。

[4]使用stop（）方法终止线程，在上一个版本的JDK中，sun公司已经说明：Thread.stop, Thread.suspend and Thread.resume都已经不被推荐使用。因为会导致程序出现不可想象的状况。

小例子如下：

 1 package com.beiyan.thread;
 2 
 3 public class ThreadStartStop {
 4 
 5     public static void main(String[] args) throws InterruptedException {
 6         ThreadStartStop startStop = new ThreadStartStop();
 7         ThreadA a = startStop.new ThreadA();// ThreadA和ThreadB
 8         ThreadB tb = startStop.new ThreadB(); // 是内部类，所以要先实例化主类，才能new两个线程对象
 9         a.start(); // ThreadA extends Thread 可以直接启动，
10         Thread b = new Thread(tb);// ThreadB implements Runnable
11         b.start(); // 必须要先实例化一个Thread 对象，在Thread 对象里面启动
12 
13         Thread.sleep(3000);// 主线程休息3秒
14         a.StopThread();
15         System.out.println("---------用 interupt（）终止线程----------");
16         ThreadC c = startStop.new ThreadC();
17         c.start();
18         c.interrupt();
19 
20     }
21 
22     class ThreadA extends Thread {
23         private boolean running = false;
24 
25         // 重写Start方法
26         public void start() {
27             System.out.println("ThreadA启动");
28             this.running = true;
29             super.start();
30         }
31 
32         // run方法
33         public void run() {
34 
35             try {
36                 while (running) {
37                     Thread.sleep(4000);
38                     System.out.println("ThreadA 执行中。。。");
39 
40                     // wait();
41                 }
42             } catch (InterruptedException e) {
43                 System.out.println("ThreadA end！");
44             }
45         }
46 
47         // 自定义线程停止方法
48         public void StopThread() {
49             System.out.println("ThreadA Stop");
50             running = false;
51         }
52     }
53 
54     class ThreadB implements Runnable {
55 
56         @Override
57         public void run() {
58 
59             System.out.println("ThreadB执行中。。。");
60             try {
61                 Thread.sleep(1000);
62             } catch (InterruptedException e) {
63                 System.out.println("ThreadB Stop");
64             }
65             System.out.println("ThreadB 结束");
66         }
67 
68     }
69 
70     class ThreadC extends Thread {
71 
72         // 重写Start方法
73         public void start() {
74             System.out.println("ThreadC启动");
75             super.start();
76         }
77 
78         // run方法
79         public void run() {
80 
81             try {
82                 while (!Thread.interrupted()) {
83                     Thread.sleep(3000);
84                     System.out.println("ThreadC 执行中。。。");
85                     // wait();
86                 }
87             } catch (InterruptedException e) {
88                 System.out.println("ThreadC end！");
89             }
90         }
91 
92     }
93 }

运行结果如下：

ThreadA启动
ThreadB执行中。。。
ThreadB 结束
ThreadA Stop
---------用 interupt（）终止线程----------
ThreadC启动
ThreadA 执行中。。。

可以看出：

1、ThreadA是采用 flage标志位的方式终止线程的，最后一句结果是：ThreadA 执行中。。。当线程终止后，线程A还在继续执行，可见采用while(flag){}方法终止线程时，若线程出现Sleep（）或者wait()阻塞时，并不能很好的结束线程。

2、ThreadC是采用interrupt()方法终止线程的。程序会丢出InterruptedException异常，因而使得执行绪离开run()方法。

3、线程ThreadA 和ThreadB 的启动方式。

三、线程的互斥

　　在操作系统中，有临界区，某些时刻只允许一个进程访问临界区。在Java中，对象也有临界区。在某些时候只允许一个线程访问临界区，称为线程的互斥。

在类的方法中使用synchronized（）关键字可以保证同一时刻只有一个线程进入该方法。

 1 public class Synchronized {
 2 
 3     private int money = 1000;
 4     private int money2 = 1000;
 5 
 6     // 用synchronized关键字定义一个同步的方法。
 7     public synchronized void add(int p) {
 8         System.out.println("已有money： " + money + "   存入： " + p + "  总共：" + (money + p));
 9         money += p;
10     }
11 
12     // 没有使用synchronized
13     public void add2(int p) {
14         System.out.println("已有money2： " + money2 + "   存入： " + p + "  总共：" + (money2 + p));
15         money2 += p;
16     }
17 
18     public static void main(String[] args) {
19         Synchronized sync = new Synchronized();
20         // 没有使用synchronized，进行线程互斥
21         ThreadTest2 p1 = new ThreadTest2(sync, 300);
22         ThreadTest2 p2 = new ThreadTest2(sync, 200);
23         ThreadTest2 p3 = new ThreadTest2(sync, 100);
24         p1.start();
25         p2.start();
26         p3.start();
27         // 使用synchronized，进行线程互斥
28         ThreadTest t1 = new ThreadTest(sync, 300);
29         ThreadTest t2 = new ThreadTest(sync, 200);
30         ThreadTest t3 = new ThreadTest(sync, 100);
31         t1.start();
32         t2.start();
33         t3.start();
34     }
35 
36 }
37 
38 // 定义一个线程类，用于增加money
39 class ThreadTest extends Thread {
40     private Synchronized syn = null;
41     private int moneyAdd = 0;
42 
43     public ThreadTest(Synchronized synchronized1, int money)
44     {
45         this.syn = synchronized1;
46         this.moneyAdd = money;
47     }
48 
49     public void run() {
50         syn.add(moneyAdd);
51     }
52 }
53 
54 // 定义一个线程类，用于增加money2
55 class ThreadTest2 extends Thread {
56     private Synchronized syn = null;
57     private int moneyAdd = 0;
58 
59     public ThreadTest2(Synchronized synchronized1, int money)
60     {
61         this.syn = synchronized1;
62         this.moneyAdd = money;
63     }
64 
65     public void run() {
66         syn.add2(moneyAdd);
67     }
68 }

运行结果如下：

已有money2： 1000 存入： 300 总共：1300
已有money2： 1000 存入： 200 总共：1200
已有money2： 1000 存入： 100 总共：1100
已有money： 1000 存入： 300 总共：1300
已有money： 1300 存入： 200 总共：1500
已有money： 1500 存入： 100 总共：1600

money2是没有使用synchronized进行同步处理的。

money是使用synchronized进行同步处理的。

可见使用synchronized同步机制实现线程的互斥运行，从而避免出现错误。

四、线程协作

有时候多个线程需要协作，线程A往缓冲区里面写数据，线程B从缓冲区里读取数据，当缓冲区满时，线程A必须等待；当缓冲区为空时，线程B必须等待。

在synchronized代码块里使用wait（）方法，能够使当前线程进入等待状态，并释放当前线程用于的对象锁。

在synchronized代码块里使用notify（）或者notifyall（）方法可以使当前线程释放对象锁，并唤醒其他正在等待该对象锁的线程。当有多个线程在等待该对象锁时，由Java虚拟机决定被唤醒的进程。

例子如下：

 1 package com.beiyan.thread;
 2 
 3 import java.util.Vector;
 4 
 5 public class WaitNotify {
 6     // 内部类，实现task的减少和增加
 7     class ThreadTask extends Thread {
 8         private Vector task = new Vector();
 9 
10         public void run() {
11             while (!Thread.interrupted()) {
12                 synchronized (this) {
13                     while (task.size() == 0) {
14                         System.out.println("资源紧张，进入等待。。。");
15                         try {
16                             wait();
17                             System.out.println("等待结束。。。");
18                         } catch (InterruptedException e) {
19                             // TODO Auto-generated catch block
20                             e.printStackTrace();
21                         }
22                     }
23                     try {
24                         sleep(1000);
25                         System.out.println("做完了一个任务");
26                         task.remove(task.size() - 1);
27                     } catch (InterruptedException e) {
28                         // TODO Auto-generated catch block
29                         e.printStackTrace();
30                     }
31                 }
32             }
33         }
34 
35         // 增加task 供使用
36         public void addTask(String str) {
37             synchronized (this) {
38                 task.add(str);
39                 System.out.println("增加了一个任务");
40                 notify();
41             }
42         }
43     }
44 
45     public static void main(String[] args) throws InterruptedException {
46         WaitNotify notify = new WaitNotify();
47         ThreadTask task = notify.new ThreadTask();
48         task.start();
49         Thread.sleep(1000);
50         for (int i = 0; i < 3; i++) {
51             task.addTask("str" + i);
52             Thread.sleep(1000);
53         }
54 
55     }
56 }

从例子可以看出，task线程中，调用start（），进而执行run（）方法的内容，让没有资源（工作任务）时，task线程进入wait（）状态，释放对线程对象的锁，这时main线程调用task的addTask()方法，使任务增加一个，调用notify（）方法并通知线程，有资源可以继续执行。

五、线程join

有时候一个线程需要等待其他线程执行完毕后再进行操作，这是一种等待关系，也是一种协作。

在当前线程中调用线程A的join（参数 b），表示：当前线程必须等待线程A执行长为 b 的时间再能继续执行。

若参数为空，则表示线程A执行完之后，当前线程才能继续执行。

例子如下：

 1 package com.beiyan.thread;
 2 
 3 public class Join {
 4     class ThreadA extends Thread {
 5         private int id;
 6         private String name;
 7 
 8         public ThreadA(int a, String b)
 9         {
10             this.id = a;
11             this.name = b;
12         }
13 
14         public void run() {
15             int i = 0;
16             while (i < 5) {
17                 System.out.println(this.name + " 执行中。。。");
18                 try {
19                     Thread.sleep(500);
20                 } catch (InterruptedException e) {
21                     e.printStackTrace();
22 
23                 }
24                 i++;
25             }
26         }
27     }
28 
29     public static void main(String[] args) throws InterruptedException {
30         Join join = new Join();
31         ThreadA a = join.new ThreadA(1, "线程A");
32         a.start();
33         a.join(); // 线程A并入主线程，线程A执行完毕后，下面的for语句，才开始执行
34 
35         for (int i = 0; i < 5; i++) {
36             System.out.println("Main Thread.....");
37         }
38     }
39 }

执行结果如下：

线程A 执行中。。。
线程A 执行中。。。
线程A 执行中。。。
线程A 执行中。。。
线程A 执行中。。。
Main Thread.....
Main Thread.....
Main Thread.....
Main Thread.....
Main Thread.....

线程A join()主线程后，成为主线程的一部分，合并成一个线程，所以按顺序执行。

六、Object实现生产者、消费者问题

　　生产者，消费者问题是一个多线程协作问题，生产者负责生产产品，并存入仓库，消费者从仓库中获得产品并消费。

例子如下：

 1 package com.beiyan.thread;
 2 
 3 import java.util.LinkedList;
 4 
 5 public class ProdutConsume extends Thread {
 6 
 7     private LinkedList<Object> wareHouse = new LinkedList<Object>();
 8     private final int MAX = 4;
 9 
10     // 生产者内部类
11     class Produt extends Thread {
12         public void run() {
13 
14             while (!Thread.interrupted()) {
15                 synchronized (wareHouse) {
16                     try {
17                         while (wareHouse.size() == MAX) {
18                             System.out.println("仓库已满，正在等待消费");
19                             wareHouse.wait();
20 
21                         }
22                         Object obj = new Object();
23                         if (wareHouse.add(obj)) {
24                             System.out.println("生产一个新产品");
25                             Thread.sleep((long) (Math.random() * 1000));
26                             wareHouse.notify();
27                         }
28                     } catch (InterruptedException e) {
29                         System.out.println("Producter Stop!!");
30                     }
31 
32                 }
33             }
34 
35         }
36     }
37 
38     // 消费者内部类
39     class Comsumer extends Thread {
40 
41         public void run() {
42 
43             while (!Thread.interrupted()) {
44                 synchronized (wareHouse) {
45                     try {
46                         while (wareHouse.size() == 0) {
47                             System.out.println("仓库为空，正在等待");
48                             wareHouse.wait();
49                         }
50                         wareHouse.removeLast();
51                         System.out.println("消费一个新产品");
52                         Thread.sleep((long) (Math.random() * 500));
53                         wareHouse.notify();
54                     } catch (InterruptedException e) {
55                         System.out.println("Comsumer Stop!!");
56                     }
57 
58                 }
59             }
60 
61         }
62     }
63 
64     public static void main(String[] args) throws InterruptedException {
65         ProdutConsume ps = new ProdutConsume();
66         Produt produt = ps.new Produt();
67         Comsumer comsumer = ps.new Comsumer();
68         produt.start();
69         comsumer.start();
70 
71     }
72 }

七、Lock类实现生产者、消费者问题

　　java JDK1.5版本后，出现了Condition。它用来替代传统的Object的wait()、notify()实现线程间的协作。使用Condition的await()、signal()这种方式实现线程间协作，比传统方式更加安全和高效。

　　synchronized却只有一把锁，lock类可以有多把锁，比较灵活。对于生产者消费者问题，可以对仓库的满和空各设一把锁。

举个例子：

当有多个线程读写文件时，读操作和写操作会发生冲突现象，写操作和写操作会发生冲突现象，但是读操作和读操作不会发生冲突现象。

　　但是采用synchronized关键字来实现同步的话，就会导致一个问题：

　　如果多个线程都只是进行读操作，所以当一个线程在进行读操作时，其他线程只能等待无法进行读操作。

　　因此就需要一种机制来使得多个线程都只是进行读操作时，线程之间不会发生冲突，通过Lock就可以办到。

代码：

 1 package com.beiyan.thread;
 2 
 3 import java.awt.Container;
 4 import java.util.LinkedList;
 5 import java.util.concurrent.TimeUnit;
 6 import java.util.concurrent.locks.Condition;
 7 import java.util.concurrent.locks.Lock;
 8 import java.util.concurrent.locks.ReentrantLock;
 9 
10 public class ProductConsumer2 extends Thread {
11 
12     private LinkedList<Object> wareHouse = new LinkedList<Object>();
13     private final int MAX = 4;
14     private final Lock lock = new ReentrantLock();
15     private Condition full = lock.newCondition();
16     private Condition empty = lock.newCondition();
17 
18     // 生产者内部类
19     class Produt extends Thread {
20         public void run() {
21 
22             while (!Thread.interrupted()) {
23                 lock.lock();
24                 try {
25                     while (wareHouse.size() == MAX) {
26                         System.out.println("仓库已满，正在等待消费");
27                         full.await();
28                     }
29                     Object obj = new Object();
30                     if (wareHouse.add(obj)) {
31                         System.out.println("生产一个新产品");
32                         Thread.sleep((long) (Math.random() * 1000));
33                         empty.signal();
34                     }
35                 } catch (InterruptedException e) {
36                     System.out.println("Producter Stop!!");
37                 }
38                 lock.unlock();
39 
40             }
41         }
42 
43     }
44 
45     // 消费者内部类
46     class Comsumer extends Thread {
47 
48         public void run() {
49             while (!Thread.interrupted()) {
50                 lock.lock();
51                 try {
52                     while (wareHouse.size() == 0) {
53                         System.out.println("仓库为空，正在等待");
54                         empty.await();
55                     }
56                     wareHouse.removeLast();
57                     System.out.println("消费一个新产品");
58                     Thread.sleep((long) (Math.random() * 500));
59                     full.signal();
60                 } catch (InterruptedException e) {
61                     System.out.println("Comsumer Stop!!");
62                 }
63                 lock.unlock();
64 
65             }
66 
67         }
68     }
69 
70     public static void main(String[] args) throws InterruptedException {
71         ProductConsumer2 ps = new ProductConsumer2();
72         Produt produt = ps.new Produt();
73         Comsumer comsumer = ps.new Comsumer();
74         produt.start();
75         comsumer.start();
76 
77     }
78 }

运行结果如下：

生产一个新产品
生产一个新产品
生产一个新产品
生产一个新产品
仓库已满，正在等待消费
消费一个新产品
消费一个新产品
消费一个新产品
消费一个新产品
仓库为空，正在等待
生产一个新产品
生产一个新产品
生产一个新产品
生产一个新产品
仓库已满，正在等待消费
消费一个新产品
消费一个新产品
消费一个新产品
消费一个新产品
仓库为空，正在等待
生产一个新产品
生产一个新产品

八、线程优先级

与操作系统中的进程一样，Java线程也有优先级，在同等情况下，对于两个同时启动的线程，优先级高的先执行。

Java线程优先级分为10个级别，数字越大，级别越高，默认为5；

Thread 的setPriority（）可以设置线程的优先级。

代码如下：

 1 package com.beiyan.thread;
 2 
 3 public class Priority {
 4     public static void main(String[] args) {
 5         Priority priority = new Priority();
 6         ThreadPriority t1 = priority.new ThreadPriority(1);
 7         ThreadPriority t2 = priority.new ThreadPriority(2);
 8         System.out.println("线程t2的默认优先级: " + t2.getPriority());
 9         t1.setPriority(6);
10         t1.start();
11         t2.start();
12     }
13 
14     class ThreadPriority extends Thread {
15         private int id;
16 
17         public ThreadPriority(int a)
18         {
19             this.id = a;
20         }
21 
22         public void run() {
23             for (int i = 1; i < 5; i++) {
24                 System.out.println("Thread " + id + " 正在执行。。。。");
25                 try {
26                     Thread.sleep((long) (Math.random() * 2000));
27                 } catch (InterruptedException e) {
28                     System.out.println("Thread " + id + " interrupt");
29                 }
30             }
31         }
32     }
33 }

执行结果：

线程t2的默认优先级: 5
Thread 1 正在执行。。。。
Thread 2 正在执行。。。。
Thread 1 正在执行。。。。
Thread 1 正在执行。。。。
Thread 1 正在执行。。。。
Thread 2 正在执行。。。。
Thread 2 正在执行。。。。
Thread 2 正在执行。。。。

线程1的优先级设置为6时，级别比线程2高，故线程1比线程2优先执行。

九、守护线程

有一种线程叫做守护线程（Daemon线程），如Java虚拟机的垃圾回收线程，它们在后台运行，为非守护线程提供服务。

Thread的setDaemon实例方法设置线程是否为守护线程，参数为true表示该线程为守护线程。

线程运行后，setDaemon实例方法无效，即必须在调用start（）方法之前调用setDaemon方法。

程序中启动的线程默认为非守护线程，但在守护线程中启动的线程都是守护线程。

当程序中，所有的非守护线程都结束时，守护线程自动结束。

例子如下：

 1 package com.beiyan.thread;
 2 
 3 public class Daemon {
 4 
 5     public static void main(String[] args) {
 6 
 7         Thread t1 = new MyCommon();
 8 
 9         Thread t2 = new Thread(new MyDaemon());
10 
11         t2.setDaemon(true); // 设置为守护线程
12 
13         t2.start();
14 
15         t1.start();
16     }
17 }
18 
19 //普通user线程
20 class MyCommon extends Thread {
21     public void run() {
22 
23         for (int i = 0; i < 4; i++) {
24 
25             System.out.println("用户第" + i + "次执行！");
26 
27             try {
28 
29                 Thread.sleep(100);
30             }
31 
32             catch (InterruptedException e) {
33 
34                 e.printStackTrace();
35             }
36         }
37 
38     }
39 }
40 
41 // 守护线程，守护线程要设置为无限循环，或者运行时间长一点，不然用户线程（非守护）还没结束，守护线程已经结束。
42 class MyDaemon implements Runnable {
43 
44     public void run() {
45 
46         int i = 0;
47         try {
48             while (true) {
49 
50                 System.out.println("守护线程第" + i + "次执行！");
51 
52                 Thread.sleep(100);
53 
54                 i++;
55 
56             }
57         } catch (
58 
59         InterruptedException e) {
60 
61             e.printStackTrace();
62 
63         } finally {
64             System.out.println("守护线程结束");// 验证守护线程的finally是否执行
65         }
66 
67     }
68 }

运行结果如下：

用户第0次执行！
守护线程第0次执行！
守护线程第1次执行！
用户第1次执行！
守护线程第2次执行！
用户第2次执行！
守护线程第3次执行！
用户第3次执行！
守护线程第4次执行！

可以看出，在普通用户线程结束运行后，虽然守护线程没执行完，但也立即结束。

并且，守护线程finally（）部分的代码是不执行的。

学习异常时说，finall（）最后必须执行的。但对于守护线程来说不适用。

十、线程池

在进行socket网络编程时，往往需要多个服务器都能连接到服务器，服务器为每个连接到服务器的用户开你一个线程进行处理，假如连接到服务器上的用户非常多，那么服务器的线程就会越用越少，最好的解决办法是使用线程池。

服务器启动时，分配何时数量的线程到一个线程池内，当有用户连上服务器之后，服务器从线程池中分配一个线程给用户，当线程池的线程分配完毕后，其他新连接的用户处于等待状态。

当有用户与服务器断开连接后，服务器重新分配线程。

具体例子放到下一篇Socket网络编程总结里面吧。

最后，激励下自己：

学习编程切忌浮躁，天亮后，面包会有的，牛奶会有的。

秒客网

JAVA 多线程学习总结

二、线程的启动与停止

三、线程的互斥

四、线程协作

五、线程join

六、Object实现生产者、消费者问题

七、Lock类实现生产者、消费者问题

八、线程优先级

九、守护线程

十、线程池

相关文章

JAVA 多线程学习总结

二、线程的启动与停止

三、线程的互斥

四、线程协作

五、线程join

六、Object实现生产者、消费者问题

七、Lock类 实现生产者、消费者问题

八、线程优先级

九、守护线程

十 、线程池

相关文章

七、Lock类实现生产者、消费者问题

十、线程池