分享
 
 
 

Java多线程及其同步实现原理

王朝java/jsp·作者佚名  2008-05-18
窄屏简体版  字體: |||超大  

一. 实现多线程

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数据。

 
 
 
免责声明:本文为网络用户发布,其观点仅代表作者个人观点,与本站无关,本站仅提供信息存储服务。文中陈述内容未经本站证实,其真实性、完整性、及时性本站不作任何保证或承诺,请读者仅作参考,并请自行核实相关内容。
2023年上半年GDP全球前十五强
 百态   2023-10-24
美众议院议长启动对拜登的弹劾调查
 百态   2023-09-13
上海、济南、武汉等多地出现不明坠落物
 探索   2023-09-06
印度或要将国名改为“巴拉特”
 百态   2023-09-06
男子为女友送行,买票不登机被捕
 百态   2023-08-20
手机地震预警功能怎么开?
 干货   2023-08-06
女子4年卖2套房花700多万做美容:不但没变美脸,面部还出现变形
 百态   2023-08-04
住户一楼被水淹 还冲来8头猪
 百态   2023-07-31
女子体内爬出大量瓜子状活虫
 百态   2023-07-25
地球连续35年收到神秘规律性信号,网友:不要回答!
 探索   2023-07-21
全球镓价格本周大涨27%
 探索   2023-07-09
钱都流向了那些不缺钱的人,苦都留给了能吃苦的人
 探索   2023-07-02
倩女手游刀客魅者强控制(强混乱强眩晕强睡眠)和对应控制抗性的关系
 百态   2020-08-20
美国5月9日最新疫情:美国确诊人数突破131万
 百态   2020-05-09
荷兰政府宣布将集体辞职
 干货   2020-04-30
倩女幽魂手游师徒任务情义春秋猜成语答案逍遥观:鹏程万里
 干货   2019-11-12
倩女幽魂手游师徒任务情义春秋猜成语答案神机营:射石饮羽
 干货   2019-11-12
倩女幽魂手游师徒任务情义春秋猜成语答案昆仑山:拔刀相助
 干货   2019-11-12
倩女幽魂手游师徒任务情义春秋猜成语答案天工阁:鬼斧神工
 干货   2019-11-12
倩女幽魂手游师徒任务情义春秋猜成语答案丝路古道:单枪匹马
 干货   2019-11-12
倩女幽魂手游师徒任务情义春秋猜成语答案镇郊荒野:与虎谋皮
 干货   2019-11-12
倩女幽魂手游师徒任务情义春秋猜成语答案镇郊荒野:李代桃僵
 干货   2019-11-12
倩女幽魂手游师徒任务情义春秋猜成语答案镇郊荒野:指鹿为马
 干货   2019-11-12
倩女幽魂手游师徒任务情义春秋猜成语答案金陵:小鸟依人
 干货   2019-11-12
倩女幽魂手游师徒任务情义春秋猜成语答案金陵:千金买邻
 干货   2019-11-12
 
推荐阅读
 
 
 
>>返回首頁<<
 
靜靜地坐在廢墟上,四周的荒凉一望無際,忽然覺得,淒涼也很美
© 2005- 王朝網路 版權所有