一． 实现多线程
1. 虚假的多线程
例1：
public class TestThread { int i=0, j=0; public void go(int flag){ while(true){ try{ Thread.sleep(100); } catch(InterruptedException e){ System.out.println("Interrupted"); } if(flag==0) i++; System.out.println("i=" + i); } else{ j++; System.out.println("j=" + j); } } } public static void main(String[] args){ new TestThread().go(0); new TestThread().go(1); }}
上面程序的运行结果为：
i=1
i=2
i=3
。。。
结果将一直打印出I的值。我们的意图是当在while循环中调用sleep()时，另一个线程就将起动，打印出j的值，但结果却并不是这样。关于sleep()为什么不会出现我们预想的结果，在下面将讲到。
2. 实现多线程
通过继承class Thread或实现Runnable接口，我们可以实现多线程
2.1 通过继承class Thread实现多线程
class Thread中有两个最重要的函数run()和start()。
1) run()函数必须进行覆写，把要在多个线程中并行处理的代码放到这个函数中。
2) 虽然run()函数实现了多个线程的并行处理，但我们不能直接调用run()函数，而是通过调用start()函数来调用run()函数。在调用start()的时候，start()函数会首先进行与多线程相关的初始化（这也是为什么不能直接调用run()函数的原因），然后再调用run()函数。
例2：
public class TestThread extends Thread{ private static int threadCount = 0; private int threadNum = ++threadCount; private int i = 5; public void run(){ while(true){ try{ Thread.sleep(100); } catch(InterruptedException e){ System.out.println("Interrupted"); } System.out.println("Thread " + threadNum + " = " + i); if(--i==0) return; } } public static void main(String[] args){ for(int i=0; i<5; i++) new TestThread().start(); }}
运行结果为：
Thread 1 = 5
Thread 2 = 5
Thread 3 = 5
Thread 4 = 5
Thread 5 = 5
Thread 1 = 4
Thread 2 = 4
Thread 3 = 4
Thread 4 = 4
Thread 1 = 3
Thread 2 = 3
Thread 5 = 4
Thread 3 = 3
Thread 4 = 3
Thread 1 = 2
Thread 2 = 2
Thread 5 = 3
Thread 3 = 2
Thread 4 = 2
Thread 1 = 1
Thread 2 = 1
Thread 5 = 2
Thread 3 = 1
Thread 4 = 1
Thread 5 = 1
从结果可见，例2能实现多线程的并行处理。
＊＊：在上面的例子中，我们只用new产生Thread对象，并没有用reference来记录所产生的Thread对象。根据垃圾回收机制，当一个对象没有被reference引用时，它将被回收。但是垃圾回收机制对Thread对象“不成立”。因为每一个Thread都会进行注册动作，所以即使我们在产生Thread对象时没有指定一个reference指向这个对象，实际上也会在某个地方有个指向该对象的reference，所以垃圾回收器无法回收它们。
3) 通过Thread的子类产生的线程对象是不同对象的线程
class TestSynchronized extends Thread{ public TestSynchronized(String name){ super(name); } public synchronized static void prt(){ for(int i=10; i<20; i++){ System.out.println(Thread.currentThread().getName() + " : " + i); try{ Thread.sleep(100); } catch(InterruptedException e){ System.out.println("Interrupted"); } } } public synchronized void run(){ for(int i=0; i<3; i++){ System.out.println(Thread.currentThread().getName() + " : " + i); try{ Thread.sleep(100); } catch(InterruptedException e){ System.out.println("Interrupted"); } } }}public class TestThread{ public static void main(String[] args){ TestSynchronized t1 = new TestSynchronized("t1"); TestSynchronized t2 = new TestSynchronized("t2"); t1.start(); t1.start(); //（1） //t2.start(); （2） }}
运行结果为：
t1 : 0
t1 : 1
t1 : 2
t1 : 0
t1 : 1
t1 : 2
由于是同一个对象启动的不同线程，所以run()函数实现了synchronized。如果去掉（2）的注释，把代码（1）注释掉，结果将变为：
t1 : 0
t2 : 0
t1 : 1
t2 : 1
t1 : 2
t2 : 2
由于t1和t2是两个对象，所以它们所启动的线程可同时访问run()函数。
2.2 通过实现Runnable接口实现多线程
如果有一个类，它已继承了某个类，又想实现多线程，那就可以通过实现Runnable接口来实现。
1) Runnable接口只有一个run()函数。
2) 把一个实现了Runnable接口的对象作为参数产生一个Thread对象，再调用Thread对象的start()函数就可执行并行操作。如果在产生一个Thread对象时以一个Runnable接口的实现类的对象作为参数，那么在调用start()函数时，start()会调用Runnable接口的实现类中的run()函数。
例3.1：
public class TestThread implements Runnable{ private static int threadCount = 0; private int threadNum = ++threadCount; private int i = 5; public void run(){ while(true){ try{ Thread.sleep(100); } catch(InterruptedException e){ System.out.println("Interrupted"); } System.out.println("Thread " + threadNum + " = " + i); if(--i==0) return; } } public static void main(String[] args){ for(int i=0; i<5; i++) new Thread(new TestThread()).start(); //（1） }}
运行结果为：
Thread 1 = 5
Thread 2 = 5
Thread 3 = 5
Thread 4 = 5
Thread 5 = 5
Thread 1 = 4
Thread 2 = 4
Thread 3 = 4
Thread 4 = 4
Thread 4 = 3
Thread 5 = 4
Thread 1 = 3
Thread 2 = 3
Thread 3 = 3
Thread 4 = 2
Thread 5 = 3
Thread 1 = 2
Thread 2 = 2
Thread 3 = 2
Thread 4 = 1
Thread 5 = 2
Thread 1 = 1
Thread 2 = 1
Thread 3 = 1
Thread 5 = 1
例3是对例2的修改，它通过实现Runnable接口来实现并行处理。代码（1）处可见，要调用TestThread中的并行操作部分，要把一个TestThread对象作为参数来产生Thread对象，再调用Thread对象的start()函数。
3) 同一个实现了Runnable接口的对象作为参数产生的所有Thread对象是同一对象下的线程。
例3.2：
package mypackage1;public class TestThread implements Runnable{ public synchronized void run(){ for(int i=0; i<5; i++){ System.out.println(Thread.currentThread().getName() + " : " + i); try{ Thread.sleep(100); } catch(InterruptedException e){ System.out.println("Interrupted"); } } } public static void main(String[] args){ TestThread testThread = new TestThread(); for(int i=0; i<5; i++) //new Thread(testThread, "t" + i).start(); （1） new Thread(new TestThread(), "t" + i).start(); （2） }}
运行结果为：
t0 : 0
t1 : 0
t2 : 0
t3 : 0
t4 : 0
t0 : 1
t1 : 1
t2 : 1
t3 : 1
t4 : 1
t0 : 2
t1 : 2
t2 : 2
t3 : 2
t4 : 2
t0 : 3
t1 : 3
t2 : 3
t3 : 3
t4 : 3
t0 : 4
t1 : 4
t2 : 4
t3 : 4
t4 : 4
由于代码（2）每次都是用一个新的TestThread对象来产生Thread对象的，所以产生出来的Thread对象是不同对象的线程，所以所有Thread对象都可同时访问run()函数。如果注释掉代码（2），并去掉代码（1）的注释，结果为：
t0 : 0
t0 : 1
t0 : 2
t0 : 3
t0 : 4
t1 : 0
t1 : 1
t1 : 2
t1 : 3
t1 : 4
t2 : 0
t2 : 1
t2 : 2
t2 : 3
t2 : 4
t3 : 0
t3 : 1
t3 : 2
t3 : 3
t3 : 4
t4 : 0
t4 : 1
t4 : 2
t4 : 3
t4 : 4
由于代码（1）中每次都是用同一个TestThread对象来产生Thread对象的，所以产生出来的Thread对象是同一个对象的线程，所以实现run()函数的同步。
二． 共享资源的同步
1. 同步的必要性
例4：
class Seq{ private static int number = 0; private static Seq seq = new Seq(); private Seq() {} public static Seq getInstance(){ return seq; } public int get(){ number++; //（a） return number; //（b） }}public class TestThread{ public static void main(String[] args){ Seq.getInstance().get(); //（1） Seq.getInstance().get(); //（2） }}
上面是一个取得序列号的单例模式的例子，但调用get()时，可能会产生两个相同的序列号：
当代码（1）和（2）都试图调用get()取得一个唯一的序列。当代码（1）执行完代码（a），正要执行代码（b）时，它被中断了并开始执行代码（2）。一旦当代码（2）执行完（a）而代码（1）还未执行代码（b），那么代码（1）和代码（2）就将得到相同的值。
2. 通过synchronized实现资源同步
2.1 锁标志
2.1.1 每个对象都有一个标志锁。当对象的一个线程访问了对象的某个synchronized数据（包括函数）时，这个对象就将被“上锁”，所以被声明为synchronized的数据（包括函数）都不能被调用（因为当前线程取走了对象的“锁标志”）。只有当前线程访问完它要访问的synchronized数据，释放“锁标志”后，同一个对象的其它线程才能访问synchronized数据。
2.1.2 每个class也有一个“锁标志”。对于synchronized static数据（包括函数）可以在整个class下进行锁定，避免static数据的同时访问。
例5：
class Seq{ private static int number = 0; private static Seq seq = new Seq(); private Seq() {} public static Seq getInstance(){ return seq; } public synchronized int get(){ //（1） number++; return number; }}
例5在例4的基础上，把get()函数声明为synchronized，那么在同一个对象中，就只能有一个线程调用get()函数，所以每个线程取得的number值就是唯一的了。
例6：
class Seq{ private static int number = 0; private static Seq seq = null; private Seq() {}synchronized public static Seq getInstance(){ //（1） if(seq==null) seq = new Seq();return seq; } public synchronized int get(){ number++; return number; }}
例6把getInstance()函数声明为synchronized，那样就保证通过getInstance()得到的是同一个seq对象。
2.2 non-static的synchronized数据只能在同一个对象的纯种实现同步访问，不同对象的线程仍可同时访问。
例7：
class TestSynchronized implements Runnable{ public synchronized void run(){ //（1） for(int i=0; i<10; i++){System.out.println(Thread.currentThread().getName() + " : " + i);/*（2）*/ try{ Thread.sleep(100); } catch(InterruptedException e){ System.out.println("Interrupted"); } } }}public class TestThread{ public static void main(String[] args){ TestSynchronized r1 = new TestSynchronized(); TestSynchronized r2 = new TestSynchronized(); Thread t1 = new Thread(r1, "t1"); Thread t2 = new Thread(r2, "t2"); //(3) //Thread t2 = new Thread(r1, "t2"); （4） t1.start(); t2.start(); }}
运行结果为：
t1 : 0
t2 : 0
t1 : 1
t2 : 1
t1 : 2
t2 : 2
t1 : 3
t2 : 3
t1 : 4
t2 : 4
t1 : 5
t2 : 5
t1 : 6
t2 : 6
t1 : 7
t2 : 7
t1 : 8
t2 : 8
t1 : 9
t2 : 9
虽然我们在代码（1）中把run()函数声明为synchronized，但由于t1、t2是两个对象（r1、r2）的线程，而run()函数是non-static的synchronized数据，所以仍可被同时访问（代码（2）中的sleep()函数由于在暂停时不会释放“标志锁”，因为线程中的循环很难被中断去执行另一个线程，所以代码（2）只是为了显示结果）。
如果把例7中的代码（3）注释掉，并去年代码（4）的注释，运行结果将为：
t1 : 0
t1 : 1
t1 : 2
t1 : 3
t1 : 4
t1 : 5
t1 : 6
t1 : 7
t1 : 8
t1 : 9
t2 : 0
t2 : 1
t2 : 2
t2 : 3
t2 : 4
t2 : 5
t2 : 6
t2 : 7
t2 : 8
t2 : 9
修改后的t1、t2是同一个对象（r1）的线程，所以只有当一个线程（t1或t2中的一个）执行run()函数，另一个线程才能执行。
2.3 对象的“锁标志”和class的“锁标志”是相互独立的。
例8：
class TestSynchronized extends Thread{ public TestSynchronized(String name){ super(name); } public synchronized static void prt(){ for(int i=10; i<20; i++){ System.out.println(Thread.currentThread().getName() + " : " + i); try{ Thread.sleep(100); } catch(InterruptedException e){ System.out.println("Interrupted"); } } } public synchronized void run(){ for(int i=0; i<10; i++){ System.out.println(Thread.currentThread().getName() + " : " + i); try{ Thread.sleep(100); } catch(InterruptedException e){ System.out.println("Interrupted"); } } }}public class TestThread{ public static void main(String[] args){ TestSynchronized t1 = new TestSynchronized("t1"); TestSynchronized t2 = new TestSynchronized("t2"); t1.start(); t1.prt(); //（1） t2.prt(); //（2） }}
运行结果为：
main : 10
t1 : 0
main : 11
t1 : 1
main : 12
t1 : 2
main : 13
t1 : 3
main : 14
t1 : 4
main : 15
t1 : 5
main : 16
t1 : 6
main : 17
t1 : 7
main : 18
t1 : 8
main : 19
t1 : 9
main : 10
main : 11
main : 12
main : 13
main : 14
main : 15
main : 16
main : 17
main : 18
main : 19
在代码（1）中，虽然是通过对象t1来调用prt()函数的，但由于prt()是静态的，所以调用它时不用经过任何对象，它所属的线程为main线程。
由于调用run()函数取走的是对象锁，而调用prt()函数取走的是class锁，所以同一个线程t1（由上面可知实际上是不同线程）调用run()函数且还没完成run()函数时，它就能调用prt()函数。但prt()函数只能被一个线程调用，如代码（1）和代码（2），即使是两个不同的对象也不能同时调用prt()。
3. 同步的优化
1) synchronized block
语法为：synchronized(reference){ do this }
reference用来指定“以某个对象的锁标志”对“大括号内的代码”实施同步控制。
例9：
class TestSynchronized implements Runnable{ static int j = 0; public synchronized void run(){for(int i=0; i<5; i++){ //（1） System.out.println(Thread.currentThread().getName() + " : " + j++); try{ Thread.sleep(100); } catch(InterruptedException e){ System.out.println("Interrupted"); } } } } public class TestThread{ public static void main(String[] args){ TestSynchronized r1 = new TestSynchronized(); TestSynchronized r2 = new TestSynchronized(); Thread t1 = new Thread(r1, "t1"); Thread t2 = new Thread(r1, "t2"); t1.start(); t2.start(); }}
运行结果为：
t1 : 0
t1 : 1
t1 : 2
t1 : 3
t1 : 4
t2 : 5
t2 : 6
t2 : 7
t2 : 8
t2 : 9
上面的代码的run()函数实现了同步，使每次打印出来的j总是不相同的。但实际上在整个run()函数中，我们只关心j的同步，而其余代码同步与否我们是不关心的，所以可以对它进行以下修改：
class TestSynchronized implements Runnable{ static int j = 0; public void run(){ for(int i=0; i<5; i++){ //（1） synchronized(this){ System.out.println(Thread.currentThread().getName() + " : " + j++); } try{ Thread.sleep(100); } catch(InterruptedException e){ System.out.println("Interrupted"); } } }}public class TestThread{ public static void main(String[] args){ TestSynchronized r1 = new TestSynchronized(); TestSynchronized r2 = new TestSynchronized(); Thread t1 = new Thread(r1, "t1"); Thread t2 = new Thread(r1, "t2"); t1.start(); t2.start(); }}
运行结果为：
t1 : 0
t2 : 1
t1 : 2
t2 : 3
t1 : 4
t2 : 5
t1 : 6
t2 : 7
t1 : 8
t2 : 9
由于进行同步的范围缩小了，所以程序的效率将提高。同时，代码（1）指出，当对大括号内的println()语句进行同步控制时，会取走当前对象的“锁标志”，即对当前对象“上锁”，不让当前对象下的其它线程执行当前对象的其它synchronized数据。 |
|
|
|
|
| |
| |
| |
![]() 整理发布
发言人:cxw 日期：2003-11-25
解除了我的疑惑
谢谢！！！
发言人:过客 日期：2003-12-27
3) 通过Thread的子类产生的线程对象是不同对象的线程,运行是怎么报异常呢？
Exception in thread "main" java.lang.IllegalThreadStateException
at java.lang.Thread.start(Native Method)
at TestThread2.main(TestThread2.java:26)
t1 : 0
t1 : 1
t
发言人:swlh2002 日期：2004-03-04
老兄，你的源代码看起来好累啊
发言人:过客 日期：2004-04-21
你的代码太累人了，没有很多人会看你的。
发言人:过客 日期：2004-04-23
用JBuilder重排一下格式，发现是很好的文章！谢谢！
发言人:过客 日期：2004-05-14
qusi
发言人:txh2002 日期：2004-05-14
很好啊，讲的很透彻，就是源码看起来累啊
发言人:tghello 日期：2004-05-18
看起来很吃力,能不能重排下,节省我们和后面人的时间!
发言人:wuxs 日期：2004-05-21
我在学习的过程中，有个问题：
如果线程类的某个方法被同步，那么如果在这个方法中用到了sleep()方法，则同步不能实现。是我的代码有误 还是确实是这样？我用的是websphere 5
发言人:wuxs 日期：2004-05-21
还有，如果我在主程序中创建了线程类的对象实例，那么在该线程类的方法中执行Thread.currentThread().getName()时，显示的是主线程，而不是该线程类。
为什么？
发言人:过客 日期：2004-06-21
老大，能不能把代码整理一下
发言人:过客 日期：2004-06-23
日你妈
发言人:过客 日期：2004-07-06
挺好的
发言人:过客 日期：2004-12-03
文章中的精髓
发言人:过客 日期：2004-12-29
代码太难看了
发言人:过客 日期：2004-12-29
代码太乱了，我的眼都要看花了
发言人:过客 日期：2005-03-09
class Seq{ private static int number = 0; private static Seq seq = new Seq(); private Seq() {} public static Seq getInstance(){ return seq; } public int get(){ number++; //（a） return number; //（b） }}public class TestThread{ public static void main(String[] args){ Seq.getInstance().get(); //（1） Seq.getInstance().get(); //（2） }}
上面是一个取得序列号的单例模式的例子，但调用get()时，可能会产生两个相同的序列号：
当代码（1）和（2）都试图调用get()取得一个唯一的序列。当代码（1）执行完代码（a），正要执行代码（b）时，它被中断了并开始执行代码（2）。一旦当代码（2）执行完（a）而代码（1）还未执行代码（b），那么代码（1）和代码（2）就将得到相同的值。
这也是个虚拟的多线程，绝不可能会产生两个相同的序列号
发言人:过客 日期：2005-03-09
class Seq{ private static int number = 0; private static Seq seq = new Seq(); private Seq() {} public static Seq getInstance(){ return seq; } public synchronized int get(){ //（1） number++; return number; }}
例5在例4的基础上，把get()函数声明为synchronized，那么在同一个对象中，就只能有一个线程调用get()函数，所以每个线程取得的number值就是唯一的了。
这个也有问题。
发言人:过客 日期：2005-03-15
可以再举些例子吗?
我想你已经说得很好了!
发言人:过客 日期：2005-03-28
谁能整理一下代码，我是初学，有点困难
发言人:过客 日期：2005-04-21
好东西~
发言人:过客 日期：2005-05-19
public class TestThread extends Thread{
private static int threadCount = 0;
private int threadNum = ++threadCount;
private int i = 5;
public void run(){
while(true){
try{ Thread.sleep(100);}
catch(InterruptedException e)
{ System.out.println("Interrupted"); }
System.out.println("Thread " + threadNum + " = " + i);
if(--i==0)
return;
}
}
public static void main(String[] args){
for(int i=0; i<5; i++)
new TestThread().start();
}
}
发言人:过客 日期：2005-05-19
class TestSynchronized extends Thread{
public TestSynchronized(String name){super(name); }
public synchronized static void prt(){
for(int i=10; i<20; i++){
System.out.println(Thread.currentThread().getName() + " : " + i);
try{ Thread.sleep(100); }
catch(InterruptedException e){ System.out.println("Interrupted"); }
}
}
public synchronized void run(){
for(int i=0; i<3; i++){
System.out.println(Thread.currentThread().getName() + " : " + i);
try{ Thread.sleep(100); }
catch(InterruptedException e){ System.out.println("Interrupted"); }
}
}
}
public class TestThread{
public static void main(String[] args){
TestSynchronized t1 = new TestSynchronized("t1");
TestSynchronized t2 = new TestSynchronized("t2");
t1.start();
t2.start();
}
}
发言人:过客 日期：2005-08-01
我有一个问题,就是主进程是键盘触发的,当我调用run 方法的时候,就发现主进程不走拉,我是用runnable的方法的.
发言人:过客 日期：2005-08-24
我人为GET()例子没有说服力
发言人:过客 日期：2005-08-24
还有些例子的结构没有充分说明理论问题
发言人:过客 日期：2005-08-24
不过总体还可以
发言人:过客 日期：2005-08-28
好是好，就是我怎么看起来这么要命
发言人:过客 日期：2005-09-20
老兄，对多线程理解得比较到位，但你的代码怎么搞的啊？
发言人:过客 日期：2005-10-14
代码写得太不规范了
发言人:过客 日期：2005-11-22
你的东西是给别人看的
发言人:过客 日期：2005-11-29
大哥，把代码整理一下，好不好？
发言人:过客 日期：2005-12-29
class TestSynchronized extends Thread{
public TestSynchronized(String name){super(name); }
public synchronized static void prt(){
for(int i=10; i<20; i++){
System.out.println(Thread.currentThread().getName() + " : " + i);
try{ Thread.sleep(100); }
catch(InterruptedException e){ System.out.println("Interrupted"); }
}
}
public synchronized void run(){
for(int i=0; i<3; i++){
System.out.println(Thread.currentThread().getName() + " : " + i);
try{ Thread.sleep(100); }
catch(InterruptedException e){ System.out.println("Interrupted"); }
}
}
}
public class TestThread{
public static void main(String[] args){
TestSynchronized t1 = new TestSynchronized("t1");
TestSynchronized t2 = new TestSynchronized("t2");
t1.start();
t2.start();
}
}
| | | |
管理
整理发布
浙公网安备 33010602011771号