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

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

来自:掘金(作者:蒋老湿)

原文链接: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关键字将解决线程之间可见性, 强制线程每次读取该值的时候都去“主内存”中取值

 

 

 

 

展开阅读全文

没有更多推荐了,返回首页