首页 > > 程序设计 > Java技术 >

多线程安全（一）

2018-07-27 06:24:51来源：博客园阅读 ()

首先感谢授课XXX老师。

1.什么是线程安全问题

　　当多个线程共享同一个全局变量，做写的操作时候，可能会受到其他线程的干扰，导致数据出现问题，这种现象就叫做线程安全问题。做读的时候不会产生线程安全问题。

什么安全：多个线程同时共享一个全局变量，做写操作的时候会发生线程安全。

多个线程共享同一个局部变量做写的操作时候，不会发生线程安全问题。

2.如何解决简单的线程安全问题（锁）

　　所谓简单就是不涉及分布式，集群等行列。

因为用以下几种解决方法完全得不到解决（实际上也就是两种）！！！

①　使用　synchronized 代码块

②　使用　synchronized 函数

③　使用　静态同步代码块　

抢夺cpu资源高的线程会首先拿到锁，然后进入逻辑中进行操作，其他线程只能进行等待，然后这个线程执行完毕后释放锁，这个时候其他线程会争夺这个锁，也就会产生资源争夺的问题，所以synchronized 的效率是很低的，然后抢夺cpu资源高的线程再次进入逻辑进行操作，以此类推。

案例

以抢车票为例，代码会尽量简洁。

100张火车票，两个售票窗口。同时出售火车票，在不解决安全问题的情况下看一看会出现什么问题。

 1 package com.mydream.cn;
 2 
 3 class Train extends Thread {
 4     int count = 1;    // 售票次数
 5     @Override
 6     public  void run() {
 7         while (count<=100) {
 8             try {
 9                 Thread.currentThread().sleep(30);//为了让程序满足并发条件，让他进入睡眠状态。好让后面同时进行
10             } catch (InterruptedException e) {
11                 e.printStackTrace();
12             }
13             sale();
14         }
15     }
16     // 售票方法逻辑
17     public void sale() { 
18         System.out.println(count);
19         count++;
20     }
21 }
22 public class TrainDemo {
23     public static void main(String[] args) {
24             Train t = new Train();
25             Thread th2 = new Thread(t);
26             Thread th1 = new Thread(t);
27             th1.start();
28             th2.start();
29     }
30 }

运行结果是出现了101张票！并且在开始时候还出现了重复的票数，例如1，1，3，这种情况，并不是我们想象的1~100。

那么是什么原因呢？？？

思路分析：

　　首先定义了一个全局变量count然后开启两个线程但是是一个对象，也就是同时操作一个全局变量。在主函数main中运行他们，th1线程和th2线程因为有一个sleep函数会等待30毫秒，这样就有机会创造出代码并发的可能性。

分析一

　　1，1，3，这种不按顺序走的逻辑思维。首先两个线程都得到释放，那么就同时进入system.out打印方法中，然后就会打印出1 ， 1 ，3这种不安顺序的代码。这种想起来应该很简单的。也就是说同时进入的时候因为都是>=100，第一次一起进入你打印 1 我也打印 1

分析二　

　　第101张票出现的情况，按照上面思路，当运行到第100张的时候，第一个线程打印出了100，然后进行了+1操作，而在判断程序中第二个线程已经进入到sale()逻辑方法中了，此时他是100，因为地换一个线程的+1操作，导致他变成了101，然后因为判断是>=100所以后面的进不来了。才导致会打印出101的情况。

解决方法一

 1 // 售票方法逻辑
 2     public void sale() { 
 3         synchronized(this){
 4             // 再次判断逻辑，因为进入到这里可能都是100，再次进行判断即可
 5             if (count<=100) {
 6                 System.out.println(count);
 7                 count++;
 8             }
 9         }
10     }

synchronized 代码块，在售票方法逻辑中加入代码块，并且写入判断逻辑，可能有人会说为什么还要在写入判断逻辑？我直接写入判断逻辑不加synchronized 不是一样么，请记住synchronized 是用来进行线程安全同步的，既然是同步那么就会安全，可是synchronized 已经进入了sale()方法中了，那么我要是同时都是100进入那也没毛病啊~~~~。所以在此加入逻辑就会防止101的出现。

synchronized 代码块中括号中的变量该放什么呢？答案是放什么都可以，只要线程中使用的是同一把锁就可以了。

例如：

 1 private Object obj =  new Object();
 2     
 3     // 售票方法逻辑
 4     public void sale() { 
 5         synchronized(obj){
 6             // 再次判断逻辑，因为进入到这里可能都是100，再次进行判断即可
 7             if (count<=100) {
 8                 System.out.println(count);
 9                 count++;
10             }
11         }
12     }

解决方法二

1     // 售票方法逻辑
2     public synchronized void sale() { 
3         if (count<=100) {
4             System.out.println(count);
5             count++;
6         }
7     }

synchronized 函数，synchronized 原理就是使用this当锁，我们可以假设一种情况，也是两个线程，分别用不同的锁，这里不同的锁就是 synchronized 函数和 synchronized 代码块用this当锁，如果发现是同步的，那么就证明了 synchronized 函数是用this当锁的，相反就不是，在这里答案是是的。

解决方式三

static synchronized 函数就是在synchronized 函数前面加上 static。如果一旦加入了static 那么 synchronized 代码块this锁不会和它同步了。

static 关键字是比所有代码都先编译的，所以也就不会有this的说法，难道你能在static修饰的方法中调用this么？可能是不可以的了。

那么这种锁用的是什么呢？答案是 .class 文件。如何测试呢？相同的方法，把 synchronized 代码块锁换成类名.class 测试是否同步。答案是同步的。

模拟 this 和同步函数是否相同

 1 class ThreadTrain2 implements Runnable {
 2     // 总共有一百张火车 当一变量被static修饰的话存放在永久区，当class文件被加载的时候就会被初始化。
 3     private static int train1Count = 100;
 4     private Object oj = new Object();
 5     public boolean flag = true;
 6     @Override
 7     public void run() {
 8         // 为了能够模拟程序一直在抢票的话。 where
 9         if (flag) {
10                   //执行同步代码块this锁
11                   while (train1Count > 0) {
12             
13                       synchronized (this) {
14                           if(train1Count>0){
15                               try {
16                                   Thread.sleep(50);
17                               } catch (Exception e) {
18                                   // TODO: handle exception
19                               }
20                               System.out.println(Thread.currentThread().getName()+ ",出售第" + (100 - train1Count + 1) + "票");
21                               train1Count--;
22                           }
23                       }
24                     
25                 }
26         }
27         else{
28              // 同步函数
29             while (train1Count > 0) {
30             
31                 // 出售火車票
32                 sale();
33             }
34         }
35         
36     }
37 
38     public   synchronized void sale() {
39 
40         // 同步代码块 synchronized 包裹需要线程安全的问题。
41         // synchronized (oj) {
42         if (train1Count > 0) {
43             try {
44                 Thread.sleep(50);
45             } catch (Exception e) {
46                 // TODO: handle exception
47             }
48             System.out.println(Thread.currentThread().getName() + ",出售第" + (100 - train1Count + 1) + "票");
49             train1Count--;
50         }
51         // }
52 
53     }
54 }
55 
56 public class ThreadDemo2 {
57 
58     public static void main(String[] args) throws InterruptedException {
59         ThreadTrain2 threadTrain2 = new ThreadTrain2();
60         Thread t1 = new Thread(threadTrain2, "窗口①");
61         Thread t2 = new Thread(threadTrain2, "窗口②");
62         t1.start();
63         Thread.sleep(40);
64         threadTrain2.flag=false;
65         t2.start();
66     }
67 
68 }

有多线程安全的解决那么就会出现一些问题，出现死锁状态，也就是说两个锁的状态是你等我解锁，我等你解锁。直接上代码

package com.itmayiedu;

class ThreadTrain3 implements Runnable {
    // 总共有一百张火车 当一变量被static修饰的话存放在永久区，当class文件被加载的时候就会被初始化。
    private static int train1Count = 100;
    private Object oj = new Object();
    public boolean flag = true;

    @Override
    public void run() {
        // 为了能够模拟程序一直在抢票的话。 where
        if (flag) {
            // 执行同步代码块this锁
            while (true) {
                synchronized (oj) {
                    sale();
                }
            }
        } else {
            // 同步函数
            while (true) {

                // 出售火車票
                sale();
            }
        }

    }

    public synchronized void sale() {

        // 同步代码块 synchronized 包裹需要线程安全的问题。
        synchronized (oj) {
            if (train1Count > 0) {
                try {
                    Thread.sleep(50);
                } catch (Exception e) {
                    // TODO: handle exception
                }
                System.out.println(Thread.currentThread().getName() + ",出售第" + (100 - train1Count + 1) + "票");
                train1Count--;
            }
        }

    }
}

public class ThreadDemo3 {

    public static void main(String[] args) throws InterruptedException {
        ThreadTrain3 threadTrain3 = new ThreadTrain3();
        Thread t1 = new Thread(threadTrain3, "窗口①");
        Thread t2 = new Thread(threadTrain3, "窗口②");
        t1.start();
        Thread.sleep(40);
        threadTrain3.flag = false;
        t2.start();
    }

}