Java线程同步与单例模式的结合学习

最近接触了一个项目的业务，是web客户端执行的备份和还原操作问题，当一个客户端点击了备份或还原操作时，在其它的web客户端则不能同时进行备份或还原，直到第一个客户端执行完全（需要5个小时），才能进行备份还原操作，并且这个项目是一个重构项目，不能影响之前的业务。

在这里我们采用的是线程同步+单例的处理办法来解决的，改最少的代码最终解决问题，自己也好好的学习了一下java线程同步和单例，闲来无事，自己对线程这一块进行了整理，把自己的一点收获写下来。

1、 A线程在访问单例service的同步方法a的时候，其他线程能否访问service的同步方法a？同步方法b？非同步方法c？

2、 两个以上线程同时访问同一个对象的同一个变量的情况下，会出现什么情况？

3、 当service不是单例（普通实例）的情况下，A线程在访问service实例的同步方法a的时候，其他线程能否访问service实例的同步方法a？同步方法b？非同步方法c？

带着上面的问题，直接贴代码

下面是一个单例类，不用多做介绍：

1 package treadTest.threadAccess;
2
3 import java.util.ArrayList;
4 import java.util.List;
5
6
7 /**
8  *
9  * @author yhd
10  * 单例类
11  */
12 public class SingletonService {
13     private static SingletonService service;
14     private List<Integer> list;
15     List<Integer> newlist = new ArrayList<Integer>();
16
17
18     private SingletonService(){}
19
20
21     public static SingletonService getInstance(){
22         if(null == service){
23             service = new SingletonService();
24         }
25         return service;
26     }
27
28
29     //同步方法A
30     public synchronized  void testA(){
31         try {
32             System.out.println("A 在执行" + Thread.currentThread());
33             Thread.sleep(5000);
34         } catch (InterruptedException e) {
35             e.printStackTrace();
36         }
37     }
38
39     //同步方法B
40     public synchronized  void testB(){
41         try {
42             System.out.println("B 在执行" + Thread.currentThread());
43             Thread.sleep(5000);
44         } catch (InterruptedException e) {
45             e.printStackTrace();
46         }
47     }
48
49     //非同步方法C
50     public void testC(){
51         System.out.println("C 在执行" + Thread.currentThread());
52         try {
53             Thread.sleep(5000);
54         } catch (InterruptedException e) {
55             e.printStackTrace();
56         }
57     }
58
59     //非同步方法C1
60     public void testC1(){
61         System.out.println("C1 在执行" + Thread.currentThread());
62     }
63
64
65     public void setList(List<Integer> list){
66         this.list = list;
67     }
68     //非同步方法D 传入参数
69     public void testD(){
70
71         System.out.println("D 在执行"+ Thread.currentThread());
72
73         for(int num:list){
74             System.out.println(num +" "+Thread.currentThread() + this.toString());
75             newlist.add(num);
76         }
77         System.out.println(newlist.toString()+"list的长度"+newlist.size());
78     }
79
80 }

下面是一个单例线程的测试类，主要是对上面的单例进行各种线程访问方法的测试

1 package treadTest;
2
3 /**
4  *
5  * @author yhd
6  * 单例模式线程测试类
7  */
8
9 public class SingletonServiceTest extends Thread{
10     //单例模式下调用同步方法的时候，该单例会被锁住，其他线程想调用
11     //该单例的其它同步方法的时候就会进行同步，如果调用的不是单例方法则不受影响
12     SingletonService service = SingletonService.getInstance();
13     static int tag = 1;
14
15     @Override
16     public void run() {
17         if(tag == 1){
18             service.testA();
19         }
20         else if(tag == 2){
21             service.testB();
22         }
23         else{
24             service.testC();
25         }
26     }
27     //这是使用代码块来实现的，相应的也学习了一下同步代码块和同步方法的使用
28     //这里的使用的是方法c和c1，这两个都不用同步了，因为这里已经对service同步了
29 //    public void run(){
30 //        synchronized (service) {
31 //            if(tag == 1){
32 //                service.testC();
33 //            }
34 //            else{
35 //                service.testC1();
36 //            }
37 //        }
38 //    }
39
40
41
42     public static void main(String args[]){
43
44         new SingletonServiceTest().start();
45         //第二个线程能否访问该单例的同一个同步方法A
46         new SingletonServiceTest().start();
47         //下面主要是让main线程歇一会儿，否则main执行完了才会启动子线程，导致tag为3，没有意义
48         try {
49             Thread.sleep(10);
50         } catch (InterruptedException e) {
51             e.printStackTrace();
52         }
53         tag = 2;
54         //第三个线程能否访问该单例的另外一个同步方法B
55         new SingletonServiceTest().start();
56         try {
57             Thread.sleep(10);
58         } catch (InterruptedException e) {
59             e.printStackTrace();
60         }
61         tag = 3;
62         //第四个线程能否访问该单例的另外一个非同步方法C
63         new SingletonServiceTest().start();
64     }
65 }

运行结果：

A 在执行Thread[Thread-1,5,main]

C 在执行Thread[Thread-3,5,main]

B 在执行Thread[Thread-2,5,main]

A 在执行Thread[Thread-0,5,main]

一开始是出现A和C，过5秒左右出现B，再过5秒出现A

说明：A线程在访问单例service的同步方法a的时候，其他线程不能否访问service的同步方法a和同步方法b，但是能访问非同步方法c

继续第二个问题的测试，直接上代码：

1 package treadTest;
2
3 import java.util.ArrayList;
4 import java.util.List;
5
6
7 //单例模式下，多个线程调用单例的用一个非同步方法，会出现什么情况？会混乱么
8 public class ServiceTest2 extends Thread{
9     static SingletonService service = SingletonService.getInstance();
10     static List<Integer> list1;
11     static List<Integer> list2;
12
13     @Override
14     public void run() {
15         service.testD();
16     }
17
18
19     public static void main(String args[]){
20         list1 = new ArrayList<Integer>();
21         //给list1添加1-1000的数据
22         for(int i=0;i<1000;i++){
23             list1.add(i);
24         }
25
26         list2 = new ArrayList<Integer>();
27         //给list2添加1000-2000的数据
28         for(int i=1001;i<2000;i++){
29             list2.add(i);
30         }
31
32
33         //给service中的list赋list1
34         service.setList(list1);
35         //启动第一个线程
36         new ServiceTest2().start();
37
38         //同理 暂停main一会
39         try {
40             Thread.sleep(10);
41         } catch (InterruptedException e) {
42             e.printStackTrace();
43         }
44
45         //给service中的list赋list1
46         service.setList(list2);
47         //启动第一个线程
48         new ServiceTest2().start();
49
50     }
51
52
53
54 }

运行结果：

998 Thread[Thread-0,5,main]treadTest.SingletonService@61de33

999 Thread[Thread-0,5,main]treadTest.SingletonService@61de33

1747 Thread[Thread-1,5,main]treadTest.SingletonService@61de33

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, ………………1538] list的长度1539 或者出异常

1748 Thread[Thread-1,5,main]treadTest.SingletonService@61de33

……

1998 Thread[Thread-1,5,main]treadTest.SingletonService@61de33

1999 Thread[Thread-1,5,main]treadTest.SingletonService@61de33

[0, 1, 2, 3, 4, 5……1001, 1002, 1003, 1004, 1005, 1006, 1007, 1008, 1009, 1010, ……1999]list的长度1999

newlist并没有是单例中方法传入的多个list而混乱 跟线程调用普通类的情形没有区别，结果说明：同时访问同一个对象的同一个变量的情况下会混乱，出现了线程安全的问题，如果想要

多个线程共享一个变量，那么可以采用ThreadLocal（线程局部变量），每个线程都有该变量的一个副本，互不影响

3、验证第三个问题

直接上代码：

类似于上面的单例类，只是改成了普通类而已

1 package treadTest;
2 public class Service {
3
4     //同步方法A
5     public synchronized  void testA(){
6         try {
7             System.out.println("A 在执行" + Thread.currentThread());
8             Thread.sleep(5000);
9         } catch (InterruptedException e) {
10             e.printStackTrace();
11         }
12     }
13
14     //同步方法B
15     public synchronized  void testB(){
16         try {
17             System.out.println("B 在执行" + Thread.currentThread());
18             Thread.sleep(5000);
19         } catch (InterruptedException e) {
20             e.printStackTrace();
21         }
22     }
23
24     //非同步方法C
25     public void testC(){
26         System.out.println("C 在执行"+ Thread.currentThread());
27         try {
28             Thread.sleep(5000);
29         } catch (InterruptedException e) {
30             e.printStackTrace();
31         }
32     }
33
34 }

非单例类的测试类如下：与上面的测试类的区别就是把类的实例化放在了run方法中，从而使得每次都new一个对象

1 package treadTest;
2
3
4 //单例模式下，该单例有两个同步方法，当一个线程调用单例的其中一个同步方法A的时候，
5 //则其他的线程的这个单例能不能调用这个A方法？另外一个同步方法B呢？非同步方法呢？
6 public class ServiceTest extends Thread{
7     //单例模式下调用同步方法的时候，该单例会被锁住，其他线程想调用
8     //该单例的其它同步方法的时候就会进行同步，如果调用的不是单例方法则不受影响
9     Service service;
10     static int tag = 1;
11
12
13
14
15
16
17     @Override
18     public void run() {
19         service = new Service();
20         if(tag == 1){
21             service.testA();
22         }
23         else if(tag == 2){
24             service.testB();
25         }
26         else{
27             service.testC();
28         }
29     }
30
31     public static void main(String args[]){
32
33         new ServiceTest().start();
34         new ServiceTest().start();
35         try {
36             Thread.sleep(10);
37         } catch (InterruptedException e) {
38             e.printStackTrace();
39         }
40         tag = 2;
41         new ServiceTest().start();
42         try {
43             Thread.sleep(10);
44         } catch (InterruptedException e) {
45             e.printStackTrace();
46         }
47         tag = 3;
48         new ServiceTest().start();
49     }
50 }

运行结果：

A 在执行Thread[Thread-0,5,main]

A 在执行Thread[Thread-1,5,main]

B 在执行Thread[Thread-2,5,main]

C 在执行Thread[Thread-3,5,main]

没有丝毫的延迟，说明当service是普通类的情况下，A线程在访问service实例的同步方法a的时候，其他线程可以访问service实例的所有同步和非同步方法

总结收获：

同步方法锁定的是调用改同步方法的实例，不允许同一个实例在不同的线程中访问实例中的同步方法。比如SingletonService的service实例，当线程a访问service的同步方法a，导致service被锁定，其它的线程想访问service的同步方法b的时候就会去尝试给service上锁，但是此时线程a已经锁定了service实例，所以其它线程无法访问service的同步方法了。但是其它线程可以访问非同步方法，非同步方法并不尝试上锁。

当不同线程中SingletonService的不同实例来访问同步方法的时候，此时只能保证同一个实例不能在不同的线程中访问同步方法，不能拒绝不同的实例访问各自实例的同步方法，因此不同实例访问互不影响

在项目的备份还原中用的就是多线程同步+单例，当一个客户端操作的时候，单例会被锁定，其它客户端在访问这个单例的同一个或其它同步方法的时候，都会等待第一个客户只需完毕。ok就这样解决了。O(∩_∩)O~

第一次发博，愚见……

附上一道华为的面试题，挺给力的，各位慢慢赏玩吧……

1 package treadTest;
2 //输出结果是什么呢？
3 public class Thread1{
4                      public static synchronized void main(String args[]){
5                                   Thread t=new Thread(){
6                                       public void run(){
7                                                pong();
8                                      }
9                                   };
10                                  t.run();
11
12
13                                   try {
14                                     Thread.sleep(100);
15                                 } catch (InterruptedException e) {
16                                     e.printStackTrace();
17                                 }
18                                  System.out.print("ping");
19                     }
20                     static synchronized void pong(){
21                                   System.out.print("pong");
22                     }
23
24 }