[转]Java多线程学习（吐血超详细总结）

1. package com.multithread.learning;
2. /**
3. *@functon 多线程学习
4. *@author 林炳文
5. *@time 2015.3.9
6. */
7. class Thread1 extends Thread{
8. private String name;
9. public Thread1(String name) {
10. this.name=name;
11. }
12. public void run() {
13. for (int i = 0; i < 5; i++) {
14. System.out.println(name + "运行  :  " + i);
15. try {
16. sleep((int) Math.random() * 10);
17. } catch (InterruptedException e) {
18. e.printStackTrace();
19. }
20. }
21. }
22. }
23. public class Main {
24. public static void main(String[] args) {
25. Thread1 mTh1=new Thread1("A");
26. Thread1 mTh2=new Thread1("B");
27. mTh1.start();
28. mTh2.start();
29. }
30. }

1. Thread1 mTh1=new Thread1("A");
2. Thread1 mTh2=mTh1;
3. mTh1.start();
4. mTh2.start();

1. /**
2. *@functon 多线程学习
3. *@author 林炳文
4. *@time 2015.3.9
5. */
6. package com.multithread.runnable;
7. class Thread2 implements Runnable{
8. private String name;
9. public Thread2(String name) {
10. this.name=name;
11. }
12. @Override
13. public void run() {
14. for (int i = 0; i < 5; i++) {
15. System.out.println(name + "运行  :  " + i);
16. try {
17. Thread.sleep((int) Math.random() * 10);
18. } catch (InterruptedException e) {
19. e.printStackTrace();
20. }
21. }
22. }
23. }
24. public class Main {
25. public static void main(String[] args) {
26. new Thread(new Thread2("C")).start();
27. new Thread(new Thread2("D")).start();
28. }
29. }

三、Thread和Runnable的区别

如果一个类继承Thread，则不适合资源共享。但是如果实现了Runable接口的话，则很容易的实现资源共享。

1. /**
2. *@functon 多线程学习 继承runnable，资源能共享
3. *@author 林炳文
4. *@time 2015.3.9
5. */
6. package com.multithread.runnable;
7. class Thread2 implements Runnable{
8. private int count=15;
9. @Override
10. public void run() {
11. for (int i = 0; i < 5; i++) {
12. System.out.println(Thread.currentThread().getName() + "运行  count= " + count--);
13. try {
14. Thread.sleep((int) Math.random() * 10);
15. } catch (InterruptedException e) {
16. e.printStackTrace();
17. }
18. }
19. }
20. }
21. public class Main {
22. public static void main(String[] args) {
23. Thread2 my = new Thread2();
24. new Thread(my, "C").start();//同一个mt，但是在Thread中就不可以，如果用同一个实例化对象mt，就会出现异常
25. new Thread(my, "D").start();
26. new Thread(my, "E").start();
27. }
28. }

六、常用函数说明

①sleep(long millis): 在指定的毫秒数内让当前正在执行的线程休眠（暂停执行）

②join():指等待t线程终止。

使用方式。

join是Thread类的一个方法，启动线程后直接调用，即join()的作用是：“等待该线程终止”，这里需要理解的就是该线程是指的主线程等待子线程的终止。也就是在子线程调用了join()方法后面的代码，只有等到子线程结束了才能执行。

为什么要用join()方法

在很多情况下，主线程生成并起动了子线程，如果子线程里要进行大量的耗时的运算，主线程往往将于子线程之前结束，但是如果主线程处理完其他的事务后，需要用到子线程的处理结果，也就是主线程需要等待子线程执行完成之后再结束，这个时候就要用到join()方法了。

不加join。

输出结果：
main主线程运行开始!
main主线程运行结束!
B 线程运行开始!
子线程B运行 : 0
A 线程运行开始!
子线程A运行 : 0
子线程B运行 : 1
子线程A运行 : 1
子线程A运行 : 2
子线程A运行 : 3
子线程A运行 : 4
A 线程运行结束!
子线程B运行 : 2
子线程B运行 : 3
子线程B运行 : 4
B 线程运行结束!
发现主线程比子线程早结束

加join

运行结果：
main主线程运行开始!
A 线程运行开始!
子线程A运行 : 0
B 线程运行开始!
子线程B运行 : 0
子线程A运行 : 1
子线程B运行 : 1
子线程A运行 : 2
子线程B运行 : 2
子线程A运行 : 3
子线程B运行 : 3
子线程A运行 : 4
子线程B运行 : 4
A 线程运行结束!
主线程一定会等子线程都结束了才结束

③yield():暂停当前正在执行的线程对象，并执行其他线程。

第一种情况：李四（线程）当执行到30时会CPU时间让掉，这时张三（线程）抢到CPU时间并执行。

第二种情况：李四（线程）当执行到30时会CPU时间让掉，这时李四（线程）抢到CPU时间并执行。

sleep()和yield()的区别
        sleep()和yield()的区别):sleep()使当前线程进入停滞状态，所以执行sleep()的线程在指定的时间内肯定不会被执行；yield()只是使当前线程重新回到可执行状态，所以执行yield()的线程有可能在进入到可执行状态后马上又被执行。
        sleep 方法使当前运行中的线程睡眼一段时间，进入不可运行状态，这段时间的长短是由程序设定的，yield 方法使当前线程让出 CPU 占有权，但让出的时间是不可设定的。实际上，yield()方法对应了如下操作：先检测当前是否有相同优先级的线程处于同可运行状态，如有，则把 CPU  的占有权交给此线程，否则，继续运行原来的线程。所以yield()方法称为“退让”，它把运行机会让给了同等优先级的其他线程
       另外，sleep 方法允许较低优先级的线程获得运行机会，但 yield()  方法执行时，当前线程仍处在可运行状态，所以，不可能让出较低优先级的线程些时获得 CPU 占有权。在一个运行系统中，如果较高优先级的线程没有调用 sleep 方法，又没有受到 I\O 阻塞，那么，较低优先级线程只能等待所有较高优先级的线程运行结束，才有机会运行。

④setPriority(): 更改线程的优先级。

MIN_PRIORITY = 1
     NORM_PRIORITY = 5
           MAX_PRIORITY = 10

用法：

Thread4 t1 = new Thread4("t1");
Thread4 t2 = new Thread4("t2");
t1.setPriority(Thread.MAX_PRIORITY);
t2.setPriority(Thread.MIN_PRIORITY);

⑤interrupt():中断某个线程，这种结束方式比较粗暴，如果t线程打开了某个资源还没来得及关闭也就是run方法还没有执行完就强制结束线程，会导致资源无法关闭

要想结束进程最好的办法就是用sleep()函数的例子程序里那样，在线程类里面用以个boolean型变量来控制run()方法什么时候结束，run()方法一结束，该线程也就结束了。

⑥wait()

Obj.wait()，与Obj.notify()必须要与synchronized(Obj)一起使用，也就是wait,与notify是针对已经获取了Obj锁进行操作，从语法角度来说就是Obj.wait(),Obj.notify必须在synchronized(Obj){...}语句块内。从功能上来说wait就是说线程在获取对象锁后，主动释放对象锁，同时本线程休眠。直到有其它线程调用对象的notify()唤醒该线程，才能继续获取对象锁，并继续执行。相应的notify()就是对对象锁的唤醒操作。但有一点需要注意的是notify()调用后，并不是马上就释放对象锁的，而是在相应的synchronized(){}语句块执行结束，自动释放锁后，JVM会在wait()对象锁的线程中随机选取一线程，赋予其对象锁，唤醒线程，继续执行。这样就提供了在线程间同步、唤醒的操作。Thread.sleep()与Object.wait()二者都可以暂停当前线程，释放CPU控制权，主要的区别在于Object.wait()在释放CPU同时，释放了对象锁的控制。

单单在概念上理解清楚了还不够，需要在实际的例子中进行测试才能更好的理解。对Object.wait()，Object.notify()的应用最经典的例子，应该是三线程打印ABC的问题了吧，这是一道比较经典的面试题，题目要求如下：

建立三个线程，A线程打印10次A，B线程打印10次B,C线程打印10次C，要求线程同时运行，交替打印10次ABC。这个问题用Object的wait()，notify()就可以很方便的解决。代码如下：

输出结果：

ABCABCABCABCABCABCABCABCABCABC

先来解释一下其整体思路，从大的方向上来讲，该问题为三线程间的同步唤醒操作，主要的目的就是ThreadA->ThreadB->ThreadC->ThreadA循环执行三个线程。为了控制线程执行的顺序，那么就必须要确定唤醒、等待的顺序，所以每一个线程必须同时持有两个对象锁，才能继续执行。一个对象锁是prev，就是前一个线程所持有的对象锁。还有一个就是自身对象锁。主要的思想就是，为了控制执行的顺序，必须要先持有prev锁，也就前一个线程要释放自身对象锁，再去申请自身对象锁，两者兼备时打印，之后首先调用self.notify()释放自身对象锁，唤醒下一个等待线程，再调用prev.wait()释放prev对象锁，终止当前线程，等待循环结束后再次被唤醒。运行上述代码，可以发现三个线程循环打印ABC，共10次。程序运行的主要过程就是A线程最先运行，持有C,A对象锁，后释放A,C锁，唤醒B。线程B等待A锁，再申请B锁，后打印B，再释放B，A锁，唤醒C，线程C等待B锁，再申请C锁，后打印C，再释放C,B锁，唤醒A。看起来似乎没什么问题，但如果你仔细想一下，就会发现有问题，就是初始条件，三个线程按照A,B,C的顺序来启动，按照前面的思考，A唤醒B，B唤醒C，C再唤醒A。但是这种假设依赖于JVM中线程调度、执行的顺序。
    wait和sleep区别
共同点： 
1. 他们都是在多线程的环境下，都可以在程序的调用处阻塞指定的毫秒数，并返回。 
2. wait()和sleep()都可以通过interrupt()方法 打断线程的暂停状态 ，从而使线程立刻抛出InterruptedException。 
   如果线程A希望立即结束线程B，则可以对线程B对应的Thread实例调用interrupt方法。如果此刻线程B正在wait/sleep /join，则线程B会立刻抛出InterruptedException，在catch() {} 中直接return即可安全地结束线程。 
   需要注意的是，InterruptedException是线程自己从内部抛出的，并不是interrupt()方法抛出的。对某一线程调用 interrupt()时，如果该线程正在执行普通的代码，那么该线程根本就不会抛出InterruptedException。但是，一旦该线程进入到 wait()/sleep()/join()后，就会立刻抛出InterruptedException 。 
不同点： 
1. Thread类的方法：sleep(),yield()等 
   Object的方法：wait()和notify()等 
2. 每个对象都有一个锁来控制同步访问。Synchronized关键字可以和对象的锁交互，来实现线程的同步。 
   sleep方法没有释放锁，而wait方法释放了锁，使得其他线程可以使用同步控制块或者方法。 
3. wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，而sleep可以在任何地方使用 
4. sleep必须捕获异常，而wait，notify和notifyAll不需要捕获异常
所以sleep()和wait()方法的最大区别是：
sleep()睡眠时，保持对象锁，仍然占有该锁；
而wait()睡眠时，释放对象锁。
但是wait()和sleep()都可以通过interrupt()方法打断线程的暂停状态，从而使线程立刻抛出InterruptedException（但不建议使用该方法）。
sleep（）方法
sleep()使当前线程进入停滞状态（阻塞当前线程），让出CUP的使用、目的是不让当前线程独自霸占该进程所获的CPU资源，以留一定时间给其他线程执行的机会;
sleep()是Thread类的Static(静态)的方法；因此他不能改变对象的机锁，所以当在一个Synchronized块中调用Sleep()方法是，线程虽然休眠了，但是对象的机锁并木有被释放，其他线程无法访问这个对象（即使睡着也持有对象锁）。
在sleep()休眠时间期满后，该线程不一定会立即执行，这是因为其它线程可能正在运行而且没有被调度为放弃执行，除非此线程具有更高的优先级。 
wait（）方法
wait()方法是Object类里的方法；当一个线程执行到wait()方法时，它就进入到一个和该对象相关的等待池中，同时失去（释放）了对象的机锁（暂时失去机锁，wait(long timeout)超时时间到后还需要返还对象锁）；其他线程可以访问；
wait()使用notify或者notifyAlll或者指定睡眠时间来唤醒当前等待池中的线程。
wiat()必须放在synchronized block中，否则会在program runtime时扔出”java.lang.IllegalMonitorStateException“异常。

七、常见线程名词解释

1. package mythread;
2. public class MyThread1 extends Thread
3. {
4. private String name;
5. public MyThread1(String name)
6. {
7. this.name = name;
8. }
9. public void run()
10. {
11. System.out.println("hello " + name);
12. }
13. public static void main(String[] args)
14. {
15. Thread thread = new MyThread1("world");
16. thread.start();
17. }
18. }

1. package mythread;
2. public class MyThread2 implements Runnable
3. {
4. private String name;
5. public void setName(String name)
6. {
7. this.name = name;
8. }
9. public void run()
10. {
11. System.out.println("hello " + name);
12. }
13. public static void main(String[] args)
14. {
15. MyThread2 myThread = new MyThread2();
16. myThread.setName("world");
17. Thread thread = new Thread(myThread);
18. thread.start();
19. }
20. }

1. package mythread;
2. class Data
3. {
4. public int value = 0;
5. }
6. class Work
7. {
8. public void process(Data data, Integer numbers)
9. {
10. for (int n : numbers)
11. {
12. data.value += n;
13. }
14. }
15. }
16. public class MyThread3 extends Thread
17. {
18. private Work work;
19. public MyThread3(Work work)
20. {
21. this.work = work;
22. }
23. public void run()
24. {
25. java.util.Random random = new java.util.Random();
26. Data data = new Data();
27. int n1 = random.nextInt(1000);
28. int n2 = random.nextInt(2000);
29. int n3 = random.nextInt(3000);
30. work.process(data, n1, n2, n3); // 使用回调函数
31. System.out.println(String.valueOf(n1) + "+" + String.valueOf(n2) + "+"
32. + String.valueOf(n3) + "=" + data.value);
33. }
34. public static void main(String[] args)
35. {
36. Thread thread = new MyThread3(new Work());
37. thread.start();
38. }
39. }