java多线程Word文档格式.docx

1、它区分为synchronized代码块和synchronized方法。synchronized的作用是让线程获取对象的同步锁。2. Thread和Runnable2.1. Thread和Runnable简介Runnable 是一个接口，该接口中只包含了一个run（）方法。它的定义如下：public interface Runnable public abstract void run（）;Runnable的作用，实现多线程。我们可以定义一个类A实现Runnable接口；然后，通过new Thread（new A（）等方式新建线程。Thread 是一个类。Thread本身就实现了Runnable

2、接口。它的声明如下：public class Thread implements Runnable Thread的作用，实现多线程。2.2. Thread和Runnable的异同点Thread 和 Runnable 的相同点：都是“多线程的实现方式”。Thread 和 Runnable 的不同点：Thread 是类，而Runnable是接口；Thread本身是实现了Runnable接口的类。我们知道“一个类只能有一个父类，但是却能实现多个接口”，因此Runnable具有更好的扩展性。此外，Runnable还可以用于“资源的共享”。即，多个线程都是基于某一个Runnable对象建立的，它们会共享

3、Runnable对象上的资源。通常，建议通过“Runnable”实现多线程！2.3. Thread和Runnable的多线程示例2.4. Thread的多线程示例下面通过示例更好的理解Thread和Runnable，借鉴网上一个例子比较具有说服性的例子。 1 / ThreadTest.java 源码 2 class MyThread extends Thread 3 private int ticket=10; 4 public void run（） 5 for（int i=0;i0） 7 System.out.println（this.getName（）+ 卖票：ticket+this.ti

4、cket-）; 8 9 10 11 ;12 13 public class ThreadTest 14 public static void main（String args） 15 / 启动3个线程t1,t2,t3；每个线程各卖10张票！16 MyThread t1=new MyThread（）;17 MyThread t2=new MyThread（）;18 MyThread t3=new MyThread（）;19 t1.start（）;20 t2.start（）;21 t3.start（）;22 23 运行结果：Thread-0 卖票：ticket10Thread-1 卖票：Threa

5、d-2 卖票：ticket9ticket8ticket7ticket6ticket5ticket4ticket3ticket2ticket1结果说明：（01） MyThread继承于Thread，它是自定义个线程。每个MyThread都会卖出10张票。（02） 主线程main创建并启动3个MyThread子线程。每个子线程都各自卖出了10张票。2.5. Runnable的多线程示例下面，我们对上面的程序进行修改。通过Runnable实现一个接口，从而实现多线程。 1 / RunnableTest.java 源码 2 class MyThread implements Runnable 7 Sy

6、stem.out.println（Thread.currentThread（）.getName（）+13 public class RunnableTest 15 MyThread mt=new MyThread（）;16 17 / 启动3个线程t1,t2,t3（它们共用一个Runnable对象），这3个线程一共卖10张票！18 Thread t1=new Thread（mt）;19 Thread t2=new Thread（mt）;20 Thread t3=new Thread（mt）;21 t1.start（）;22 t2.start（）;23 t3.start（）;24 25 （01）

7、和上面“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（）的话，会在当前线

8、程中执行run（），而并不会启动新线程！下面以代码来进行说明。class MyThread extends Thread public void run（） . ;MyThread mythread = new MyThread（）;mythread.start（）会启动一个新线程，并在新线程中运行run（）方法。而mythread.run（）则会直接在当前线程中运行run（）方法，并不会启动一个新线程来运行run（）。3.2. start（） 和 run（）的区别示例下面，通过一个简单示例演示它们之间的区别。源码如下： 1 / Demo.java 的源码 3 public MyThread（

9、String name） 4 super（name）; 5 6 7 public void run（） 8 System.out.println（Thread.currentThread（）.getName（）+ is running）; 9 10 ;11 12 public class Demo 13 public static void main（String args） 14 Thread mythread=new MyThread（mythread15 16 System.out.println（Thread.currentThread（）.getName（）+ call mythre

10、ad.run（）17 mythread.run（）;18 19 System.out.println（Thread.currentThread（）.getName（）+ call mythread.start（）20 mythread.start（）;21 22 main call mythread.run（）main is runningmain call mythread.start（）mythread is running（01） Thread.currentThread（）.getName（）是用于获取“当前线程”的名字。当前线程是指正在cpu中调度执行的线程。（02） mythrea

11、d.run（）是在“主线程main”中调用的，该run（）方法直接运行在“主线程main”上。（03） mythread.start（）会启动“线程mythread”，“线程mythread”启动之后，会调用run（）方法；此时的run（）方法是运行在“线程mythread”上。3.3. start（） 和 run（）相关源码（基于JDK1.7.0_40）Thread.java中start（）方法的源码如下：public synchronized void start（） / 如果线程不是就绪状态，则抛出异常！ if （threadStatus != 0） throw new IllegalT

12、hreadStateException（）; / 将线程添加到ThreadGroup中 group.add（this）; boolean started = false; try / 通过start0（）启动线程 start0（）; / 设置started标记 started = true; finally if （!started） group.threadStartFailed（this）; catch （Throwable ignore） start（）实际上是通过本地方法start0（）启动线程的。而start0（）会新运行一个线程，新线程会调用run（）方法。private nati

13、ve void start0（）;Thread.java中run（）的代码如下：public void run（） if （target != null） target.run（）;target是一个Runnable对象。run（）就是直接调用Thread线程的Runnable成员的run（）方法，并不会新建一个线程。4. synchronized关键字4.1. synchronized原理在java中，每一个对象有且仅有一个同步锁。这也意味着，同步锁是依赖于对象而存在。当我们调用某对象的synchronized方法时，就获取了该对象的同步锁。例如，synchronized（obj）就获取了“

14、obj这个对象”的同步锁。不同线程对同步锁的访问是互斥的。也就是说，某时间点，对象的同步锁只能被一个线程获取到！通过同步锁，我们就能在多线程中，实现对“对象/方法”的互斥访问。 例如，现在有两个线程A和线程B，它们都会访问“对象obj的同步锁”。假设，在某一时刻，线程A获取到“obj的同步锁”并在执行一些操作；而此时，线程B也企图获取“obj的同步锁” 线程B会获取失败，它必须等待，直到线程A释放了“该对象的同步锁”之后线程B才能获取到“obj的同步锁”从而才可以运行。4.2. synchronized基本规则我们将synchronized的基本规则总结为下面3条，并通过实例对它们进行说明。第

15、一条: 当一个线程访问“某对象”的“synchronized方法”或者“synchronized代码块”时，其他线程对“该对象”的该“synchronized方法”或者“synchronized代码块”的访问将被阻塞。第二条: 当一个线程访问“某对象”的“synchronized方法”或者“synchronized代码块”时，其他线程仍然可以访问“该对象”的非同步代码块。第三条: 当一个线程访问“某对象”的“synchronized方法”或者“synchronized代码块”时，其他线程对“该对象”的其他的“synchronized方法”或者“synchronized代码块”的访问将被阻塞。4

16、.2.1. 第一条当一个线程访问“某对象”的“synchronized方法”或者“synchronized代码块”时，其他线程对“该对象”的该“synchronized方法”或者“synchronized代码块”的访问将被阻塞。下面是“synchronized代码块”对应的演示程序。 1 class MyRunable implements Runnable 2 3 Override 4 public void run（） 5 synchronized（this） 6 try 7 for （int i = 0; i 5; i+） 8 Thread.sleep（100）; / 休眠100ms 9

17、 System.out.println（Thread.currentThread（）.getName（） + loop + i）;10 11 catch （InterruptedException ie） 12 13 14 15 17 public class Demo1_1 19 public static void main（String args） 20 Runnable demo = new MyRunable（）; / 新建“Runnable对象”21 22 Thread t1 = new Thread（demo, t1 / 新建“线程t1”, t1是基于demo这个Runnable

18、对象23 Thread t2 = new Thread（demo, t2 / 新建“线程t2”, t2是基于demo这个Runnable对象24 t1.start（）; / 启动“线程t1”25 t2.start（）; / 启动“线程t2” 26 27 t1 loop 0t1 loop 1t1 loop 2t1 loop 3t1 loop 4t2 loop 0t2 loop 1t2 loop 2t2 loop 3t2 loop 4run（）方法中存在“synchronized（this）代码块”，而且t1和t2都是基于demo这个Runnable对象创建的线程。这就意味着，我们可以将synch

19、ronized（this）中的this看作是“demo这个Runnable对象”；因此，线程t1和t2共享“demo对象的同步锁”。所以，当一个线程运行的时候，另外一个线程必须等待“运行线程”释放“demo的同步锁”之后才能运行。如果你确认，你搞清楚这个问题了。那我们将上面的代码进行修改，然后再运行看看结果怎么样，看看你是否会迷糊。修改后的源码如下： 1 class MyThread extends Thread 7 Override 8 public void run（） 9 synchronized（this） 10 try 11 for （int i = 0;12 Thread.slee

20、p（100）;13 System.out.println（Thread.currentThread（）.getName（） + 15 catch （InterruptedException ie） 16 17 18 19 20 21 public class Demo1_2 22 23 public static void main（String args） 24 Thread t1 = new MyThread（ / 新建“线程t1”25 Thread t2 = new MyThread（ / 新建“线程t2”26 t1.start（）;27 t2.start（）;28 29 代码说明：比较

21、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是指“当前的类对象”，即s

22、ynchronized（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代码块”时，其他线程仍然可以访问“该对象”的非同步代码块。 1 class Count 3 / 含有synchronized同步块的方法 4 public void synMethod（） synMethod loop 16 / 非同步的方法17 public void nonSynMethod（） 18 try 19 for （int i = 0;20 Thread.sleep（100）;21