java多线程Word文档格式.docx
《java多线程Word文档格式.docx》由会员分享，可在线阅读，更多相关《java多线程Word文档格式.docx（73页珍藏版）》请在冰豆网上搜索。
它区分为synchronized代码块和synchronized方法。
synchronized的作用是让线程获取对象的同步锁。
2.Thread和Runnable
2.1.Thread和Runnable简介
Runnable是一个接口，该接口中只包含了一个run（）方法。
它的定义如下：
publicinterfaceRunnable{
publicabstractvoidrun（）;
}
Runnable的作用，实现多线程。
我们可以定义一个类A实现Runnable接口；
然后，通过newThread（newA（））等方式新建线程。
Thread是一个类。
Thread本身就实现了Runnable接口。
它的声明如下：
publicclassThreadimplementsRunnable{}
Thread的作用，实现多线程。
2.2.Thread和Runnable的异同点
Thread和Runnable的相同点：
都是“多线程的实现方式”。
Thread和Runnable的不同点：
Thread是类，而Runnable是接口；
Thread本身是实现了Runnable接口的类。
我们知道“一个类只能有一个父类，但是却能实现多个接口”，因此Runnable具有更好的扩展性。
此外，Runnable还可以用于“资源的共享”。
即，多个线程都是基于某一个Runnable对象建立的，它们会共享Runnable对象上的资源。
通常，建议通过“Runnable”实现多线程！
2.3.Thread和Runnable的多线程示例
2.4.Thread的多线程示例
下面通过示例更好的理解Thread和Runnable，借鉴网上一个例子比较具有说服性的例子。
1//ThreadTest.java源码
2classMyThreadextendsThread{
3privateintticket=10;
4publicvoidrun（）{
5for（inti=0;
i<
20;
i++）{
6if（this.ticket>
0）{
7System.out.println（this.getName（）+"
卖票：
ticket"
+this.ticket--）;
8}
9}
10}
11};
12
13publicclassThreadTest{
14publicstaticvoidmain（String[]args）{
15//启动3个线程t1,t2,t3；
每个线程各卖10张票！
16MyThreadt1=newMyThread（）;
17MyThreadt2=newMyThread（）;
18MyThreadt3=newMyThread（）;
19t1.start（）;
20t2.start（）;
21t3.start（）;
22}
23}
运行结果：
Thread-0卖票：
ticket10
Thread-1卖票：
Thread-2卖票：
ticket9
ticket8
ticket7
ticket6
ticket5
ticket4
ticket3
ticket2
ticket1
结果说明：
（01）MyThread继承于Thread，它是自定义个线程。
每个MyThread都会卖出10张票。
（02）主线程main创建并启动3个MyThread子线程。
每个子线程都各自卖出了10张票。
2.5.Runnable的多线程示例
下面，我们对上面的程序进行修改。
通过Runnable实现一个接口，从而实现多线程。
1//RunnableTest.java源码
2classMyThreadimplementsRunnable{
7System.out.println（Thread.currentThread（）.getName（）+"
13publicclassRunnableTest{
15MyThreadmt=newMyThread（）;
16
17//启动3个线程t1,t2,t3（它们共用一个Runnable对象），这3个线程一共卖10张票！
18Threadt1=newThread（mt）;
19Threadt2=newThread（mt）;
20Threadt3=newThread（mt）;
21t1.start（）;
22t2.start（）;
23t3.start（）;
24}
25}
（01）和上面“MyThread继承于Thread”不同；
这里的MyThread实现了Thread接口。
（02）主线程main创建并启动3个子线程，而且这3个子线程都是基于“mt这个Runnable对象”而创建的。
运行结果是这3个子线程一共卖出了10张票。
这说明它们是共享了MyThread接口的。
3.Thread中start（）和run（）的区别
3.1.start（）和run（）的区别说明
start（）:
它的作用是启动一个新线程，新线程会执行相应的run（）方法。
start（）不能被重复调用。
run（）
run（）就和普通的成员方法一样，可以被重复调用。
单独调用run（）的话，会在当前线程中执行run（），而并不会启动新线程！
下面以代码来进行说明。
classMyThreadextendsThread{
publicvoidrun（）{
...
}
};
MyThreadmythread=newMyThread（）;
mythread.start（）会启动一个新线程，并在新线程中运行run（）方法。
而mythread.run（）则会直接在当前线程中运行run（）方法，并不会启动一个新线程来运行run（）。
3.2.start（）和run（）的区别示例
下面，通过一个简单示例演示它们之间的区别。
源码如下：
1//Demo.java的源码
3publicMyThread（Stringname）{
4super（name）;
5}
6
7publicvoidrun（）{
8System.out.println（Thread.currentThread（）.getName（）+"
isrunning"
）;
9}
10};
11
12publicclassDemo{
13publicstaticvoidmain（String[]args）{
14Threadmythread=newMyThread（"
mythread"
15
16System.out.println（Thread.currentThread（）.getName（）+"
callmythread.run（）"
17mythread.run（）;
18
19System.out.println（Thread.currentThread（）.getName（）+"
callmythread.start（）"
20mythread.start（）;
21}
22}
maincallmythread.run（）
mainisrunning
maincallmythread.start（）
mythreadisrunning
（01）Thread.currentThread（）.getName（）是用于获取“当前线程”的名字。
当前线程是指正在cpu中调度执行的线程。
（02）mythread.run（）是在“主线程main”中调用的，该run（）方法直接运行在“主线程main”上。
（03）mythread.start（）会启动“线程mythread”，“线程mythread”启动之后，会调用run（）方法；
此时的run（）方法是运行在“线程mythread”上。
3.3.start（）和run（）相关源码（基于JDK1.7.0_40）
Thread.java中start（）方法的源码如下：
publicsynchronizedvoidstart（）{
//如果线程不是"
就绪状态"
，则抛出异常！
if（threadStatus!
=0）
thrownewIllegalThreadStateException（）;
//将线程添加到ThreadGroup中
group.add（this）;
booleanstarted=false;
try{
//通过start0（）启动线程
start0（）;
//设置started标记
started=true;
}finally{
if（!
started）{
group.threadStartFailed（this）;
}
}catch（Throwableignore）{
start（）实际上是通过本地方法start0（）启动线程的。
而start0（）会新运行一个线程，新线程会调用run（）方法。
privatenativevoidstart0（）;
Thread.java中run（）的代码如下：
publicvoidrun（）{
if（target!
=null）{
target.run（）;
target是一个Runnable对象。
run（）就是直接调用Thread线程的Runnable成员的run（）方法，并不会新建一个线程。
4.synchronized关键字
4.1.synchronized原理
在java中，每一个对象有且仅有一个同步锁。
这也意味着，同步锁是依赖于对象而存在。
当我们调用某对象的synchronized方法时，就获取了该对象的同步锁。
例如，synchronized（obj）就获取了“obj这个对象”的同步锁。
不同线程对同步锁的访问是互斥的。
也就是说，某时间点，对象的同步锁只能被一个线程获取到！
通过同步锁，我们就能在多线程中，实现对“对象/方法”的互斥访问。
例如，现在有两个线程A和线程B，它们都会访问“对象obj的同步锁”。
假设，在某一时刻，线程A获取到“obj的同步锁”并在执行一些操作；
而此时，线程B也企图获取“obj的同步锁”——线程B会获取失败，它必须等待，直到线程A释放了“该对象的同步锁”之后线程B才能获取到“obj的同步锁”从而才可以运行。
4.2.synchronized基本规则
我们将synchronized的基本规则总结为下面3条，并通过实例对它们进行说明。
第一条:
当一个线程访问“某对象”的“synchronized方法”或者“synchronized代码块”时，其他线程对“该对象”的该“synchronized方法”或者“synchronized代码块”的访问将被阻塞。
第二条:
当一个线程访问“某对象”的“synchronized方法”或者“synchronized代码块”时，其他线程仍然可以访问“该对象”的非同步代码块。
第三条:
当一个线程访问“某对象”的“synchronized方法”或者“synchronized代码块”时，其他线程对“该对象”的其他的“synchronized方法”或者“synchronized代码块”的访问将被阻塞。
4.2.1.第一条
当一个线程访问“某对象”的“synchronized方法”或者“synchronized代码块”时，其他线程对“该对象”的该“synchronized方法”或者“synchronized代码块”的访问将被阻塞。
下面是“synchronized代码块”对应的演示程序。
1classMyRunableimplementsRunnable{
2
3@Override
4publicvoidrun（）{
5synchronized（this）{
6try{
7for（inti=0;
i<
5;
i++）{
8Thread.sleep（100）;
//休眠100ms
9System.out.println（Thread.currentThread（）.getName（）+"
loop"
+i）;
10}
11}catch（InterruptedExceptionie）{
12}
13}
14}
15}
17publicclassDemo1_1{
19publicstaticvoidmain（String[]args）{
20Runnabledemo=newMyRunable（）;
//新建“Runnable对象”
21
22Threadt1=newThread（demo,"
t1"
//新建“线程t1”,t1是基于demo这个Runnable对象
23Threadt2=newThread（demo,"
t2"
//新建“线程t2”,t2是基于demo这个Runnable对象
24t1.start（）;
//启动“线程t1”
25t2.start（）;
//启动“线程t2”
26}
27}
t1loop0
t1loop1
t1loop2
t1loop3
t1loop4
t2loop0
t2loop1
t2loop2
t2loop3
t2loop4
run（）方法中存在“synchronized（this）代码块”，而且t1和t2都是基于"
demo这个Runnable对象"
创建的线程。
这就意味着，我们可以将synchronized（this）中的this看作是“demo这个Runnable对象”；
因此，线程t1和t2共享“demo对象的同步锁”。
所以，当一个线程运行的时候，另外一个线程必须等待“运行线程”释放“demo的同步锁”之后才能运行。
如果你确认，你搞清楚这个问题了。
那我们将上面的代码进行修改，然后再运行看看结果怎么样，看看你是否会迷糊。
修改后的源码如下：
1classMyThreadextendsThread{
7@Override
8publicvoidrun（）{
9synchronized（this）{
10try{
11for（inti=0;
12Thread.sleep（100）;
13System.out.println（Thread.currentThread（）.getName（）+"
15}catch（InterruptedExceptionie）{
16}
17}
18}
19}
20
21publicclassDemo1_2{
22
23publicstaticvoidmain（String[]args）{
24Threadt1=newMyThread（"
//新建“线程t1”
25Threadt2=newMyThread（"
//新建“线程t2”
26t1.start（）;
27t2.start（）;
28}
29}
代码说明：
比较Demo1_2和Demo1_1，我们发现，Demo1_2中的MyThread类是直接继承于Thread，而且t1和t2都是MyThread子线程。
幸运的是，在“Demo1_2的run（）方法”也调用了synchronized（this），正如“Demo1_1的run（）方法”也调用了synchronized（this）一样！
那么，Demo1_2的执行流程是不是和Demo1_1一样呢？
如果这个结果一点也不令你感到惊讶，那么我相信你对synchronized和this的认识已经比较深刻了。
否则的话，请继续阅读这里的分析。
synchronized（this）中的this是指“当前的类对象”，即synchronized（this）所在的类对应的当前对象。
它的作用是获取“当前对象的同步锁”。
对于Demo1_2中，synchronized（this）中的this代表的是MyThread对象，而t1和t2是两个不同的MyThread对象，因此t1和t2在执行synchronized（this）时，获取的是不同对象的同步锁。
对于Demo1_1对而言，synchronized（this）中的this代表的是MyRunable对象；
t1和t2共同一个MyRunable对象，因此，一个线程获取了对象的同步锁，会造成另外一个线程等待。
4.2.2.第二条
当一个线程访问“某对象”的“synchronized方法”或者“synchronized代码块”时，其他线程仍然可以访问“该对象”的非同步代码块。
1classCount{
3//含有synchronized同步块的方法
4publicvoidsynMethod（）{
synMethodloop"
16//非同步的方法
17publicvoidnonSynMethod（）{
18try{
19for（inti=0;
20Thread.sleep（100）;
21
升级会员 