并发编程之多线程线程安全

最新推荐文章于 2024-03-20 10:15:00 发布

lip86

最新推荐文章于 2024-03-20 10:15:00 发布

阅读量107

点赞数

分类专栏： java 多线程

原文链接：https://mp.weixin.qq.com/s/Gt5gDWS-74dN7qelLWoHIw

版权

java 同时被 2 个专栏收录

119 篇文章 2 订阅

订阅专栏

多线程

8 篇文章 0 订阅

订阅专栏

来自：掘金（作者：蒋老湿）

原文链接：https://juejin.im/post/5bd967915188257f7d68134a

什么是线程安全？

为什么有线程安全问题？

当多个线程同时共享，同一个全局变量或静态变量，做写的操作时，可能会发生数据冲突问题，也就是线程安全问题。但是做读操作是不会发生数据冲突问题。

案例: 需求现在有100张火车票，有两个窗口同时抢火车票，请使用多线程模拟抢票效果。

public class ThreadTrain implements Runnable {
   private int trainCount = 10;

   @Override
   public void run() {
       while (trainCount > 0) {
           try {
               Thread.sleep(500);
               sale();
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
       }
   }

   private void sale() {
       if (trainCount > 0) {
           --trainCount;
           System.out.println(Thread.currentThread().getName() + ",出售第" + (10 - trainCount) + "张票");
       }
   }

   public static void main(String[] args) {
       ThreadTrain threadTrain = new ThreadTrain();
       Thread t1 = new Thread(threadTrain, "1台");
       Thread t2 = new Thread(threadTrain, "2台");
       t1.start();
       t2.start();
   }
}

运行结果:

一号窗口和二号窗口同时出售火车第九九张,部分火车票会重复出售。结论发现，多个线程共享同一个全局成员变量时，做写的操作可能会发生数据冲突问题。

线程安全解决办法:

问: 如何解决多线程之间线程安全问题
答: 使用多线程之间同步synchronized或使用锁(lock)。

问: 为什么使用线程同步或使用锁能解决线程安全问题呢？
答: 将可能会发生数据冲突问题(线程不安全问题)，只能让当前一个线程进行执行。代码执行完成后释放锁，让后才能让其他线程进行执行。这样的话就可以解决线程不安全问题。

问: 什么是多线程之间同步
答: 当多个线程共享同一个资源,不会受到其他线程的干扰。

问: 什么是多线程同步
答: 当多个线程共享同一个资源,不会受到其他线程的干扰。

什么是Threadlocal

ThreadLocal是一个线程的局部变量，访问某个线程拥有自己局部变量。当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。 ThreadLocal的接口方法 ThreadLocal类接口很简单，只有4个方法，我们先来了解一下：

void set(Object value)设置当前线程的线程局部变量的值。
public Object get()该方法返回当前线程所对应的线程局部变量。
public void remove()将当前线程局部变量的值删除，目的是为了减少内存的占用，该方法是JDK 5.0新增的方法。需要指出的是，当线程结束后，对应该线程的局部变量将自动被垃圾回收，所以显式调用该方法清除线程的局部变量并不是必须的操作，但它可以加快内存回收的速度。
protected Object initialValue()返回该线程局部变量的初始值，该方法是一个protected的方法，显然是为了让子类覆盖而设计的。这个方法是一个延迟调用方法，在线程第1次调用get()或set(Object)时才执行，并且仅执行1次。ThreadLocal中的缺省实现直接返回一个null。

案例:创建三个线程，每个线程生成自己独立序列号。

class Res {
    public static Integer count = 0;
    public static ThreadLocal<Integer> threadLocal = new ThreadLocal<Integer>() {
        protected Integer initialValue() {
            return 0;
        };
    };

    public Integer getNum() {
        int count = threadLocal.get() + 1;
        threadLocal.set(count);
        return count;
    }
}

public class Test006 extends Thread {

    private Res res;

    public Test006(Res res) {
        this.res = res;
    }

    @Override
    public void run() {
        for (int i = 0; i < 3; i++) {
            System.out.println(Thread.currentThread().getName() + "," + res.getNum());
        }
    }

    public static void main(String[] args) {
        Res res = new Res();
        Test006 t1 = new Test006(res);
        Test006 t2 = new Test006(res);

        t1.start();
        t2.start();
    }

}

ThreadLoca实现原理， ThreadLoca通过map集合，Map.put(“当前线程”,值)；

volatile

可见性也就是说一旦某个线程修改了该被volatile修饰的变量，它会保证修改的值会立即被更新到主存，当有其他线程需要读取时，可以立即获取修改之后的值。在Java中为了加快程序的运行效率，对一些变量的操作通常是在该线程的寄存器或是CPU缓存上进行的，之后才会同步到主存中，而加了volatile修饰符的变量则是直接读写主存。

volatile 保证了线程间共享变量的及时可见性，但不能保证原子性

class ThreadDemo004 extends Thread {
   public boolean flag = true;

   @Override
   public void run() {
       System.out.println("线程开始...");
       while (flag) {

       }
       System.out.println("线程結束...");
   }

   public void setRuning(boolean flag) {
       this.flag = flag;
   }
}

public class Test0004 {
   public static void main(String[] args) throws InterruptedException {
       ThreadDemo004 threadDemo004 = new ThreadDemo004();
       threadDemo004.start();
       Thread.sleep(3000);
       threadDemo004.setRuning(false);
       System.out.println("flag已經改為false");
       Thread.sleep(1000);
       System.out.println("flag:" + threadDemo004.flag);
   }
}

已经将结果设置为fasle为什么？还一直在运行呢。
原因:线程之间是不可见的，读取的是副本，没有及时读取到主内存结果。解决办法使用Volatile关键字将解决线程之间可见性, 强制线程每次读取该值的时候都去“主内存”中取值