J2SE知识点归纳笔记(五)---Java多线程(一)

转载：http://blog.csdn.net/coder_pig/article/details/22791141

Java多线程:

前言:

当我们使用电脑时,可以一边听歌,一边和小学生打lol,一边用QQ和基友聊天;如果你够屌的话,还可以

用wps做实验报告呢= =;那么CPU怎么同时敢这么多事情呢?这就涉及到两个名词:多进程(Process)和多线程(Thread)

Java语言的一个重要特点就是对多线程的支持,使得开发人员可以开发出同时处理多个任务的application,实现

任务的并发处理！

PS:因为多线程灰常的重要,所以这里分开两节讲,不让读者有太大的负担,这一节稍微简单一点

好了废话不多说!

相关概念:

线程的生命周期:

Java线程的创建:

代码示例:

以下两个代码实现的都是同一个功能;

完成计时的功能,每秒打印一行

继承Thread类:

[java] view plain copy

1. package com.jay.example;  
2.   
3.   
4. //自定义一个线程类继承Thread类,重写Thread中的run()方法  
5. class MyThread extends Thread  
6. {  
7.     public MyThread() {  
8.         //这里是标识进程名的,可以通过getName()获得进程的名称  
9.         super("MyThread");  
10.         System.out.println("新建一个线程:"+getName());  
11.     }  
12.       
13.     //重写的run()方法;通过循环打印1~10;  
14.     //而每秒打印一行的功能是添加了sleep(1000); 1000毫秒 = 1秒  
15.     //使用sleep需要对异常进行捕获  
16.     public void run() {       
17.         for(int i = 1;i <= 3;i++)  
18.         {  
19.             System.out.println(Thread.currentThread().getName() +" : " + i );  
20.             try {  
21.                 sleep(1000);  
22.             } catch (InterruptedException e) {  
23.                 e.printStackTrace();  
24.             }  
25.         }  
26.     }  
27. }  
28.   
29.   
30. public class ThreadTest1 {  
31.     public static void main(String[] args) {  
32.         Thread t = Thread.currentThread();  
33.           
34.         //新建一个MyThread的线程对象  
35.         MyThread mt = new MyThread();  
36.         //通过线程.start()方法启动线程中的run()方法  
37.         mt.start();  
38.         //这里是为了让线程运行完毕后才打印主线程中的语句  
39.         //join():让异步执行的线程改成同步执行,直到这个线程退出  
40.         //程序才会继续执行  
41.         try {  
42.             mt.join();  
43.         } catch (InterruptedException e) {  
44.             e.printStackTrace();  
45.         }  
46.           
47.         System.out.println("打印完毕！");  
48.     }  
49. }  

运行截图:

实现Runnable接口:

[java] view plain copy

1. package com.jay.example;  
2.   
3. //该代码实现了Runnable接口,重写了其中的run()方法  
4. class MyThread2 implements Runnable  
5. {  
6.     public void run() {  
7.         for(int i = 1;i <= 3;i++)  
8.         {  
9.             System.out.println(Thread.currentThread().getName() +" : " + i );  
10.             //调用sleep方法需要对异常进行补货  
11.             try {  
12.                 Thread.sleep(1000);  
13.             } catch (InterruptedException e) {  
14.                 // TODO Auto-generated catch block  
15.                 e.printStackTrace();  
16.             }  
17.         }         
18.     }     
19. }  
20.   
21. public class ThreadTest2 {  
22.     public static void main(String[] args) {  
23.         //实例化自定义线程  
24.         MyThread2 th = new MyThread2();  
25.         //新建一个线程对象,把子线程对象作为参数传入,后面的参数是进程的name  
26.         Thread td = new Thread(th,"MyThread2");       
27.         td.start();  
28.           
29.     }  
30. }  

运行截图：

多线程的控制:

都说了是多线程,那么就是有多个线程同时运行,这就涉及到了多线程之间的控制了

多个线程的并发执行:

如果当前有多个线程在并发执行的话,多次运行的结果可能不是唯一的

Java对于线程启动后唯一能保证的就是每个线程都被启动并且结束,但对于哪个线程优先执行,何时执行都没有保证

实例代码:两个进程打印的先后顺序

[java] view plain copy

1. package com.jay.example;  
2.   
3. /* 
4.  * 该程序演示的是线程的并发执行; 
5.  * 我们定义一个MyThread1类实现Runnable接口 
6.  * 重写run()方法,在该方法中打印区分哪个线程的语句 
7.  * 在main方法中实例化两个MyThread1对象并且作为参数 
8.  * 传递给Thread对象,start()方法调用,输出结果！ 
9.  * */  
10.   
11. class MyThread1 implements Runnable  
12. {  
13.     public void run() {  
14.         for(int i=0;i<10;i++)  
15.         {  
16.             System.out.println(Thread.currentThread().getName());  
17.         }  
18.     }  
19. }  
20.   
21. public class ThreadTest1 {  
22.       
23.     public static void main(String[] args) {  
24.           
25.         MyThread1 my1 = new MyThread1();  
26.         MyThread1 my2 = new MyThread1();  
27.           
28.         Thread t1 = new Thread(my1,"第一个线程被调用！");  
29.         Thread t2 = new Thread(my2,"第二个线程被调用！");  
30.           
31.         t1.start();  
32.         t2.start();  
33.     }     
34. }  

运行截图:

结果分析:

运行后发现,线程是交替交替运行的,也说明了Java多线程的特点;

而这里又涉及到另一个概念了,就是线程的优先级

线程的优先级:

操作系统中的线程是具有优先级的,Java运行环境采用的是固定优先级调度算法(Fixed Priority Scheduling)

某一时刻有多个线程在运行,JVM会选择优先级最高的线程运行,优先级较高的线程会抢占cpu时间,

相同优先级的线程可能顺序执行,也可能分时执行,取决于本地操作系统的线程调度策略

虽然说在任意时刻,应该是最高优先级的线程在运行,但是这样是不能保证的,调度程序有可能选择

优先级较低的线程以避免饥饿(starvation)

抢占(pre-empt)策略:当一个优先级更高的进程进行可运行状态时发生抢占,终止当正在运行的进程而

立即去执行优先级更高 的线程,而两个相同优先级的线程则采用循环执行策略(round-robin);

饥饿(starvation):当等待时间给进程的推进和响应带来明显的影响时就称发生了进程饥饿

饥饿到一定程度的进程所赋予的任务即使完成,也已经不再具有实际意义,该进程就饿死了！

 如:一个打印机文件打印的问题,采用短文件有限的策略,如果短文件太多,

 那么长文件一直无限期的推迟,那么还打印个毛啊！

在Java中,优先级从,0~10,整数数值越大,优先级越大;默认线程优先级为5;可以通过setPriority()方法改变线程的优先级;

通过getPriority()获得线程的优先级;注意Thread类优先级的几个字段:

MIN_PRIORITY(最低优先级1)    MAX_PRIORITY(最高优先级10)     NORM_PRIORITY(默认优先级5)

只能说优先级高的线程有更大的可能性获得CPU,但这并不能说优先级较低的线程就永远最后执行！！

   

代码示例:

[java] view plain copy

1. package com.jay.example;  
2.   
3. /* 
4.  * 该代码演示的是线程优先级的使用 
5.  * 定义了三个线程,重新设置了优先级 
6.  * 在调用start()方法输出哪个线程被调用了 
7.  * */  
8.   
9. class MyThread1 implements Runnable  
10. {  
11.     public void run() {  
12.         for(int i=0;i<10;i++)  
13.         {  
14.             System.out.println(Thread.currentThread().getName());  
15.         }  
16.     }  
17. }  
18.   
19. public class ThreadTest1 {  
20.       
21.     public static void main(String[] args) {  
22.           
23.         MyThread1 my1 = new MyThread1();  
24.         MyThread1 my2 = new MyThread1();  
25.         MyThread1 my3 = new MyThread1();  
26.           
27.         Thread t1 = new Thread(my1,"第一个线程被调用！");  
28.         Thread t2 = new Thread(my2,"第二个线程被调用！");  
29.         Thread t3 = new Thread(my2,"第三个线程被调用！");  
30.           
31.         t1.setPriority(Thread.MIN_PRIORITY);  
32.         t2.setPriority(Thread.MAX_PRIORITY);  
33.         t3.setPriority(Thread.NORM_PRIORITY);  
34.           
35.         System.out.println("设置后的线程优先级依次是:" + t1.getPriority() + "   " + t2.getPriority() + "  "+ t3.getPriority());  
36.           
37.         t1.start();  
38.         t2.start();  
39.         t3.start();  
40.     }     
41. }  

运行截图:

结果分析:

进程优先级最低的第一个执行?这是不是有点意外,其实不然,只要读者运行几次会发现打印结果都是不一样的;

好像我们设置了优先级没什么用,对吧?也不能说没用,只是给系统提供一个参考吧,让他优先考虑分配CPU时间给该线程

除了优先级,操作系统还要考虑其他的一些东东哦！当然,我们在开发中肯定要有方法来规定线程的执行的!那就是线程调度的一些方法!

线程调度:

按照前面的说法,线程的运行是没有保证的,那么我们还怎么玩多线程;显然是不可能的;

Thread类给我们提供了一些用于实现线程调度的方法

sleep():

让线程睡一会儿,参数是毫秒级,使用该方法时需要捕获InterruptedException异常

eg:Thread.sleep(1000);  //让当前线程休眠1秒

yield():

暂停当前线程,运行其他线程,即让出CPU运行时间,进入就绪状态,从而让其他的进程获得CPU时间执行

不过对于抢占式操作系统没有什么意义,或者说没效果

join():

想让一个线程等待另一个线程执行完毕后再继续执行的情况下使用

可以添加参数,long类型的毫秒,等待该线程终止的时间最长为多少毫秒

可以参考第一个例子,比如m.join,那么等m进程执行完毕后才能执行其他程序这样！

锁与线程同步:

当有两个或以上线程操作同一时刻并发地访问同一资源,可能会带来一些问题;

比如比较经典的生产者和消费者的问题,如果生产者还没生产,那么消费者就进行消费了,那么这样肯定是错误的！

所以这里要引入一个锁的概念:就是对共享的资源加以限制,让该资源同一时间仅仅只能够有一个线程对他进行访问

使用实例:

定义一个资源类,在里面实现两个同步方法,再对其进行访问

代码:

[java] view plain copy

1. package com.jay.example;  
2.   
3. /* 
4.  * 该代码演示的是同步方法与同步块的使用 
5.  * 定义一个资源类,分别用同步方法和同步代码块定义两个同步的方法 
6.  * 然后定义一个线程类,在线程类中实现对该资源的访问 
7.  * 因为加了同步锁,所以同一时间只允许一个进程访问 
8.  * 实例化两个自定义线程对象,作为传给两个Thread对象 
9.  * 调用start()方法,启动自定义线程的run()方法,完成打印输出 
10.  * */  
11.   
12. class Source  
13. {  
14.     //定义同步方法  
15.     synchronized void method1()  
16.     {  
17.         System.out.println("进入方法一,获得锁");  
18.         try {  
19.             Thread.sleep(1000);  
20.         } catch (InterruptedException e) {  
21.             e.printStackTrace();  
22.         }  
23.         System.out.println("方法一执行完毕,释放锁");  
24.     }  
25.       
26.       
27.     //在该方法中使用同步块  
28.     void method2()  
29.     {  
30.         synchronized(this)  
31.         {  
32.             System.out.println("进入方法二,获得锁");  
33.             try {  
34.                 Thread.sleep(1000);  
35.             } catch (InterruptedException e) {  
36.                 e.printStackTrace();  
37.             }  
38.             System.out.println("方法二执行完毕,释放锁");  
39.         }  
40.     }  
41.       
42. }  
43.   
44. //定义一个操作资源的线程类:  
45. class MyThread implements Runnable  
46. {     
47.     private String name;  
48.     Source s = null;  
49.       
50.     MyThread(Source s,String name)  
51.     {  
52.         this.s = s;  
53.         this.name = name;  
54.     }  
55.       
56.       
57.     public void run() {  
58.         if(name.equals("method1"))s.method1();  
59.         else   
60.         {System.out.println("方法二启动,准备调用第二个方法");s.method2();}  
61.     }  
62. }  
63.   
64. public class ThreadTest2 {  
65.     public static void main(String[] args) {  
66.         //实例化一个资源对象传入到线程类中  
67.         Source s = new Source();  
68.         //创建两个MyThread对象  
69.         MyThread mt1 = new MyThread(s, "method1");  
70.         MyThread mt2 = new MyThread(s, "method2");  
71.           
72.         //自定义线程对象传入Thread对象中  
73.         Thread t1 = new Thread(mt1);  
74.         Thread t2 = new Thread(mt2);  
75.           
76.         //调用start方法启动两个线程  
77.         t1.start();  
78.         t2.start();  
79.     }  
80. }  

运行截图：

线程死锁问题:

简单的说就说,两个线程都在等待对方拥有的资源,就是A等B的资源,B也在等A的资源,

我不给你你不给我,就一直在那里纠结,一直无限的等下去这个就是死锁了

一个简单的死锁例子:

该代码演示的是定义了一个资源类,然后自定义了一个线程类,该类在run方法中使用了两个synchronized嵌套;

就是每个线程对象需要获得两个资源才可以运行;为了方便演示,我故意实例化了三个资源对象和自定义线程对象

一号线程需要得到1,2资源,二号线程需要得到2,3资源,三号线程需要得到3,1资源

然后每个线程都获得了对应的一个资源,一直在等另一个资源;一等二的2资源,二等三的3资源,三等一的1资源

就这样一直僵持,就形成了死锁

代码演示:

[java] view plain copy

1. package com.jay.example;  
2. /* 
3.  * 该代码演示的是进程的死锁 
4.  * 定义了一个资源类,在自定义线程的run()方法中 
5.  * 使用了synchronized的嵌套,实现一个线程需要两个资源才可以运行 
6.  * 在main()方法中依次实例化了三个:资源对象,自定义线程对象 
7.  * 让1线程需要1.2号资源；让2线程需要2.3号资源；让1线程需要3.1号资源 
8.  * 结果就互相等呗,就形成了死锁 
9.  * */  
10.   
11.   
12. //定义资源类  
13. class Resource  
14. {  
15.     String name;  
16.     public Resource(String name) {  
17.         this.name = name;  
18.     }  
19. }  
20.   
21. //自定义线程类  
22. class MyThread2 implements Runnable  
23. {  
24.     Resource res1 = null;  
25.     Resource res2 = null;  
26.     String name;  
27.       
28.     //构造方法的重写  
29.     public MyThread2(Resource res1,Resource res2,String name) {  
30.         this.res1 = res1;  
31.         this.res2 = res2;  
32.         this.name = name;  
33.     }  
34.       
35.     public void run() {  
36.         //外层synchronized块  
37.         synchronized (res1) {  
38.             System.out.println(this.name + " 获得了 "+ res1.name);  
39.             try{Thread.sleep(1000);}catch(InterruptedException e){e.printStackTrace();};  
40.             System.out.println(this.name + "等待 "+res2.name + "释放资源！");  
41.             //里层syncronized块  
42.             synchronized (res2) {  
43.                     System.out.println(this.name + "获得 了 " +res2.name);  
44.                     try{Thread.sleep(1000);}catch(InterruptedException ex){ex.printStackTrace();};  
45.                 }  
46.             }  
47.         }  
48.     }  
49.   
50.   
51. public class ThreadTest3 {  
52.     public static void main(String[] args) {  
53.         //创建资源对象  
54.         Resource res1 = new Resource("资源一");  
55.         Resource res2 = new Resource("资源二");  
56.         Resource res3 = new Resource("资源三");  
57.           
58.         //实例化三个自定义线程对象,并且把他们传给Thread对象  
59.         MyThread2 mt1 = new MyThread2(res1,res2,  "线程一");  
60.         MyThread2 mt2 = new MyThread2(res2,res3,  "线程二");  
61.         MyThread2 mt3 = new MyThread2(res3,res1,  "线程三");  
62.           
63.         Thread t1 = new Thread(mt1);  
64.         Thread t2 = new Thread(mt2);  
65.         Thread t3 = new Thread(mt3);  
66.           
67.         t1.start();  
68.         t2.start();  
69.         t3.start();  
70.     }  
71. }  

运行截图:

结果分析:

如图,就这样卡住了,但是显示程序还在运行,就这样一直在那里等啊等

这样的程序是已经死掉的没有意义的程序了,所以在编写代码的时候要

预防死锁！这就是操作系统的概念了,有兴趣的可以看下参考系统的书籍

总结:

在这一节中,我们了解了多线程的相关概念,生命周期;

以及创建线程的两个方法,多个线程的并发执行,线程的优先级

线程调度的三个常用方法;锁与线程同步的问题等

大家回去要自己动手写下代码理解下,有什么问题可以写代码测试一下

ps：清明因为回家祭祖,就没更新了,今天又继续拉,

如果对本文有什么疑问,意见,纰漏,建议的话,

欢迎指出,感激万分,谢谢！O(∩_∩)O！