ITPub博客

首页 > Linux操作系统 > Linux操作系统 > [转载]彻底明白Java的多线程-实现多线程及线程的同步

[转载]彻底明白Java的多线程-实现多线程及线程的同步

原创 Linux操作系统 作者:dinner1007 时间:2019-04-19 13:42:07 0 删除 编辑
彻底明白Java的多线程-实现多线程及线程的同步

一. 实现多线程


1. 虚假的多线程
例1:
  1. public class TestThread
  2. {
  3. int i=0, j=0;
  4. public void go(int flag){
  5. while(true){
  6. try{
  7. Thread.sleep(100);
  8. }
  9. catch(InterruptedException e){
  10. System.out.println("Interrupted");
  11. }
  12. if(flag==0)
  13. i++;
  14. System.out.println("i=" + i);
  15. }
  16. else{
  17. j++;
  18. System.out.println("j=" + j);
  19. }
  20. }
  21. }
  22. public static void main(String[] args){
  23. new TestThread().go(0);
  24. new TestThread().go(1);
  25. }
  26. }

上面程序的运行结果为:
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:
  1. public class TestThread extends Thread{
  2. private static int threadCount = 0;
  3. private int threadNum = ++threadCount;
  4. private int i = 5;
  5. public void run(){
  6. while(true){
  7. try{
  8. Thread.sleep(100); 
  9. }
  10. catch(InterruptedException e){
  11. System.out.println("Interrupted");
  12. }
  13. System.out.println("Thread " + threadNum + " = " + i);
  14. if(--i==0) return;
  15. }
  16. }
  17. public static void main(String[] args){
  18. for(int i=0; i<5; i++)
  19. new TestThread().start();
  20. }
  21. }

运行结果为:
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的子类产生的线程对象是不同对象的线程
  1. class TestSynchronized extends Thread{
  2. public TestSynchronized(String name){
  3. super(name);
  4. }
  5. public synchronized static void prt(){
  6. for(int i=10; i<20; i++){
  7. System.out.println(Thread.currentThread().getName() + " : " + i);
  8. try{
  9. Thread.sleep(100);
  10. }
  11. catch(InterruptedException e){
  12. System.out.println("Interrupted");
  13. }
  14. }
  15. }
  16. public synchronized void run(){
  17. for(int i=0; i<3; i++){
  18. System.out.println(Thread.currentThread().getName() + " : " + i);
  19. try{
  20. Thread.sleep(100);
  21. }
  22. catch(InterruptedException e){
  23. System.out.println("Interrupted");
  24. }
  25. }
  26. }
  27. }
  28. public class TestThread{
  29. public static void main(String[] args){
  30. TestSynchronized t1 = new TestSynchronized("t1");
  31. TestSynchronized t2 = new TestSynchronized("t2");
  32. t1.start();
  33. t1.start(); //(1)
  34. //t2.start(); (2)
  35. }
  36. }

运行结果为:
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:
  1. public class TestThread implements Runnable{
  2. private static int threadCount = 0;
  3. private int threadNum = ++threadCount;
  4. private int i = 5;
  5. public void run(){
  6. while(true){
  7. try{
  8. Thread.sleep(100);
  9. }
  10. catch(InterruptedException e){
  11. System.out.println("Interrupted");
  12. }
  13. System.out.println("Thread " + threadNum + " = " + i);
  14. if(--i==0) return;
  15. }
  16. }
  17. public static void main(String[] args){
  18. for(int i=0; i<5; i++)
  19. new Thread(new TestThread()).start(); //(1)
  20. }
  21. }

运行结果为:
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:
  1. package mypackage1;
  2. public class TestThread implements Runnable{
  3. public synchronized void run(){
  4. for(int i=0; i<5; i++){
  5. System.out.println(Thread.currentThread().getName() + " : " + i);
  6. try{
  7. Thread.sleep(100);
  8. }
  9. catch(InterruptedException e){
  10. System.out.println("Interrupted");
  11. }
  12. }
  13. }
  14. public static void main(String[] args){
  15. TestThread testThread = new TestThread();
  16. for(int i=0; i<5; i++)
  17. //new Thread(testThread, "t" + i).start(); (1)
  18. new Thread(new TestThread(), "t" + i).start(); (2)
  19. }
  20. }

运行结果为:
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:
  1. class Seq{
  2. private static int number = 0;
  3. private static Seq seq = new Seq();
  4. private Seq() {}
  5. public static Seq getInstance(){
  6. return seq;
  7. }
  8. public int get(){
  9. number++;  //(a)
  10. return number; //(b)
  11. }
  12. }
  13. public class TestThread{
  14. public static void main(String[] args){
  15. Seq.getInstance().get(); //(1)
  16. Seq.getInstance().get(); //(2)
  17. }
  18. }

上面是一个取得序列号的单例模式的例子,但调用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:
  1. class Seq{
  2. private static int number = 0;
  3. private static Seq seq = new Seq();
  4. private Seq() {}
  5. public static Seq getInstance(){
  6. return seq;
  7. }
  8. public synchronized int get(){ //(1)
  9. number++;
  10. return number;
  11. }
  12. }

例5在例4的基础上,把get()函数声明为synchronized,那么在同一个对象中,就只能有一个线程调用get()函数,所以每个线程取得的number值就是唯一的了。
例6:
  1. class Seq{
  2. private static int number = 0;
  3. private static Seq seq = null;
  4. private Seq() {}
  5. synchronized public static Seq getInstance(){ //(1)
  6. if(seq==null) seq = new Seq();
  7. return seq;
  8. }
  9. public synchronized int get(){
  10. number++;
  11. return number;
  12. }
  13. }

例6把getInstance()函数声明为synchronized,那样就保证通过getInstance()得到的是同一个seq对象。
2.2 non-static的synchronized数据只能在同一个对象的纯种实现同步访问,不同对象的线程仍可同时访问。
例7:
  1. class TestSynchronized implements Runnable{
  2. public synchronized void run(){ //(1)
  3. for(int i=0; i<10; i++){
  4. System.out.println(Thread.currentThread().getName() + " : " + i);
  5. /*(2)*/
  6. try{
  7. Thread.sleep(100);
  8. }
  9. catch(InterruptedException e){
  10. System.out.println("Interrupted");
  11. }
  12. }
  13. }
  14. }
  15. public class TestThread{
  16. public static void main(String[] args){
  17. TestSynchronized r1 = new TestSynchronized();
  18. TestSynchronized r2 = new TestSynchronized();
  19. Thread t1 = new Thread(r1, "t1");
  20. Thread t2 = new Thread(r2, "t2"); //(3)
  21. //Thread t2 = new Thread(r1, "t2"); (4)
  22. t1.start();
  23. t2.start();
  24. }
  25. }

运行结果为:
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:
  1. class TestSynchronized extends Thread{
  2. public TestSynchronized(String name){
  3. super(name);
  4. }
  5. public synchronized static void prt(){
  6. for(int i=10; i<20; i++){
  7. System.out.println(Thread.currentThread().getName() + " : " + i);
  8. try{
  9. Thread.sleep(100);
  10. }
  11. catch(InterruptedException e){
  12. System.out.println("Interrupted");
  13. }
  14. }
  15. }
  16. public synchronized void run(){
  17. for(int i=0; i<10; i++){
  18. System.out.println(Thread.currentThread().getName() + " : " + i);
  19. try{
  20. Thread.sleep(100);
  21. }
  22. catch(InterruptedException e){
  23. System.out.println("Interrupted");
  24. }
  25. }
  26. }
  27. }
  28. public class TestThread{
  29. public static void main(String[] args){
  30. TestSynchronized t1 = new TestSynchronized("t1");
  31. TestSynchronized t2 = new TestSynchronized("t2");
  32. t1.start();
  33. t1.prt(); //(1)
  34. t2.prt(); //(2)
  35. }
  36. }

运行结果为:
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:
  1. class TestSynchronized implements Runnable{
  2. static int j = 0;
  3. public synchronized void run(){
  4. for(int i=0; i<5; i++){
  5. //(1)
  6. System.out.println(Thread.currentThread().getName() + " : " + j++);
  7. try{
  8. Thread.sleep(100);
  9. }
  10. catch(InterruptedException e){
  11. System.out.println("Interrupted");
  12. }
  13. }
  14. }
  15. }
  16. public class TestThread{
  17. public static void main(String[] args){
  18. TestSynchronized r1 = new TestSynchronized();
  19. TestSynchronized r2 = new TestSynchronized();
  20. Thread t1 = new Thread(r1, "t1");
  21. Thread t2 = new Thread(r1, "t2");
  22. t1.start();
  23. t2.start();
  24. }
  25. }

运行结果为:
t1 : 0
t1 : 1
t1 : 2
t1 : 3
t1 : 4
t2 : 5
t2 : 6
t2 : 7
t2 : 8
t2 : 9
上面的代码的run()函数实现了同步,使每次打印出来的j总是不相同的。但实际上在整个run()函数中,我们只关心j的同步,而其余代码同步与否我们是不关心的,所以可以对它进行以下修改:
  1. class TestSynchronized implements Runnable{
  2. static int j = 0;
  3. public void run(){
  4. for(int i=0; i<5; i++){
  5. //(1)
  6. synchronized(this){
  7. System.out.println(Thread.currentThread().getName() + " : " + j++);
  8. }
  9. try{
  10. Thread.sleep(100);
  11. }
  12. catch(InterruptedException e){
  13. System.out.println("Interrupted");
  14. }
  15. }
  16. }
  17. }
  18. public class TestThread{
  19. public static void main(String[] args){
  20. TestSynchronized r1 = new TestSynchronized();
  21. TestSynchronized r2 = new TestSynchronized();
  22. Thread t1 = new Thread(r1, "t1");
  23. Thread t2 = new Thread(r1, "t2");
  24. t1.start();
  25. t2.start();
  26. }
  27. }

运行结果为:
t1 : 0
t2 : 1
t1 : 2
t2 : 3
t1 : 4
t2 : 5
t1 : 6
t2 : 7
t1 : 8
t2 : 9
由于进行同步的范围缩小了,所以程序的效率将提高。同时,代码(1)指出,当对大括号内的println()语句进行同步控制时,会取走当前对象的“锁标志”,即对当前对象“上锁”,不让当前对象下的其它线程执行当前对象的其它synchronized数据。

来自 “ ITPUB博客 ” ,链接:http://blog.itpub.net/374079/viewspace-132131/,如需转载,请注明出处,否则将追究法律责任。

请登录后发表评论 登录
全部评论

注册时间:2018-08-23

  • 博文量
    991
  • 访问量
    711314