多线程实现同步（第二天）

梦里梦外; 2022-05-13 11:52 144阅读 0赞

*  线程安全
 *  线程如何实现同步
    
     *  同步的前提
     *  实现同步的几种方式
 *  线程死锁示例
 *  多线程的三大特性
    
     *  原子性
     *  可见性
     *  有序性
 *  java内存模型（多线程可见性）
 *  Volatile
 *  ThreadLocal
    
     *  ThreadLocal的作用和目的
     *  ThreadLocal的原理
     *  ThreadLocal的方法
 *  笔试题

# 线程安全 #

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

# 线程如何实现同步 #

## 同步的前提 ##

1.  必须要有两个或者两个以上的线程。
2.  必须是多个线程使用同一个锁
3.  必须保证同步中只能有一个线程在运行
4.  好处：解决了多线程的安全问题
5.  弊端：多个线程需要判断锁，较为消耗资源、抢锁的资源。

## 实现同步的几种方式 ##

package top.nightliar.study.day02;
    
    /** * Created by Nightliar * 2018-09-12 16:37 */
    public class ThreadDemo01 { 
    
        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();
        }
    }
    
    package top.nightliar.study.day02;
    
    /** * Created by Nightliar * 2018-09-12 16:40 */
    public class ThreadTrain implements Runnable{ 
    
        private static int count = 100;  //火车票总数
    
        private Object ob = new Object();  //锁对象
    
        @Override
        public void run() {
            while (count > 0){
                try {
                    Thread.sleep(50);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //出售火车票
                sale();
            }
        }
    
        //售票方法
        private void sale(){
            if (count > 0){
                System.out.println(Thread.currentThread().getName() + "，出售第" + (100 - count + 1) + "张票");
                count-- ;
            }
        }
    }

*  同步代码块  
    使用synchronized将可能会发生线程安全问题的代码，给包括起来。

synchronized(同一个数据){
        可能会发生线程冲突问题
    }

*  同步函数  
    在方法上修饰synchronized 称为同步函数，同步函数使用的是this锁。

//加了同步代码块的售卖方法
        private void sale(){
            synchronized (ob){
                if (count > 0){
                    System.out.println(Thread.currentThread().getName() + "，出售第" + (100 - count + 1) + "张票");
                    count-- ;
                }
            }
        }

*  静态同步函数  
    方法上加上static关键字，使用synchronized 关键字修饰，静态的同步函数使用的锁是该函数所属字节码文件对象。

//同步静态方法的售卖方法
        private static synchronized void sale(){
            if (count > 0){
                System.out.println(Thread.currentThread().getName() + "，出售第" + (100 - count + 1) + "张票");
                count-- ;
            }
        }

# 线程死锁示例 #

同步中嵌套同步，导致锁无法释放，线程无法得到自己需要的锁，也不释放别人需要的锁，导致两个线程无限等待锁资源。

package top.nightliar.study.day02;
    
    /** * 线程死锁示例 * Created by Nightliar * 2018-09-12 17:46 */
    public class DeadLock implements Runnable { 
    
        boolean flag = false;
        //ob1,ob2为两个静态的锁
        private static Object ob1 = new Object();
        private static Object ob2 = new Object();
    
        public DeadLock(boolean flag) {
            this.flag = flag;
        }
    
        @Override
        public void run() {
            if (flag){
                while (true) {
                    synchronized (ob1){
                        try {
                            Thread.sleep(100);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        synchronized (ob2){
                            System.out.println("进入到true");
                        }
                    }
                }
            }else {
                while (true) {
                    synchronized (ob2){
                        try {
                            Thread.sleep(100);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        synchronized (ob1){
                            System.out.println("进入到false");
                        }
                    }
                }
            }
        }
    
        public static void main(String[] args) throws InterruptedException {
            DeadLock deadLock1 = new DeadLock(false);
            DeadLock deadLock2 = new DeadLock(true);
            new Thread(deadLock1).start();
            new Thread(deadLock2).start();
        }
    
    }

# 多线程的三大特性 #

## 原子性 ##

即一个操作或者多个操作 要么全部执行并且执行的过程不会被任何因素打断，要么就都不执行。只有线程具备原子性，在多线程下才能保证不出现一些问题。  
例如：i = i+1；其中就包括，读取i的值，计算i，写入i。这行代码在Java中是不具备原子性的，则多线程运行肯定会出问题，所以也需要我们使用同步和lock这些东西来确保这个特性了。  
原子性用来保证数据的一致性，是线程安全的一部分。

## 可见性 ##

当多个线程访问同一个变量时，一个线程修改了这个变量的值，其他线程能够立即看得到修改的值。  
若两个线程在不同的cpu，那么线程1改变了i的值还没刷新到主存，线程2又使用了i，那么这个i值肯定还是之前的，线程1对变量的修改线程没看到这就是可见性问题。

## 有序性 ##

程序执行的顺序按照代码的先后顺序执行。  
一般来说处理器为了提高程序运行效率，可能会对输入代码进行优化，它不保证程序中各个语句的执行先后顺序同代码中的顺序一致，但是它会保证程序最终执行结果和代码顺序执行的结果是一致的。  
重排序对单线程没有影响，但多线程情况下就有可能出现问题。

# java内存模型（多线程可见性） #

java内存模型决定了一个线程与另一个线程是否可见。  
java内存模型：主内存（主要存放共享的全局变量），私有本地内存（本地线程私有变量）。  
工作流程：私有本地内存持有主内存中全局变量的副本，在当前线程中修改后，刷新到主内存中。在线程中使用的全局变量都是使用的私有内存中所持有的副本，所以当一个线程将全局变量修改后，其余线程不会及时得到最新值，而是使用副本值。可以使用volatile来保证线程每次使用该值时都从主内存中拿到最新值，而不是是用副本值。

# Volatile #

保证线程可见性，但不保证原子性。

package top.nightliar.study.day02;
    
    /** * Created by Nightliar * 2018-09-13 10:10 */
    public class ThreadDemo02 extends Thread { 
    
        private boolean flag = true;
    // private volatile boolean flag = true;
    
        @Override
        public void run() {
            System.out.println("开始执行子线程....");
            while (flag) {
            }
            System.out.println("线程停止");
        }
    
        public void setRuning(boolean flag) {
            this.flag = flag;
        }
    
        public static void main(String[] args) throws InterruptedException {
            ThreadDemo02 threadVolatileDemo = new ThreadDemo02();
            threadVolatileDemo.start();
            Thread.sleep(3000);
            threadVolatileDemo.setRuning(false);
            System.out.println("flag 已经设置成false");
            Thread.sleep(1000);
            System.out.println(threadVolatileDemo.flag);
            //没有使用volatile时，线程会一直运行
        }
    
    }

# ThreadLocal #

ThreadLocal提高一个线程的局部变量，访问某个线程拥有自己局部变量。  
当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。

## ThreadLocal的作用和目的 ##

用于实现线程内的数据共享，即对于相同的程序代码，多个模块在同一个线程中运行时要共享一份数据，而在另外线程中运行时又共享另外一份数据。

## ThreadLocal的原理 ##

每个线程调用全局 ThreadLocal 对象的 set 方法，在 set 方法中，首先根据当前线程获取当前线程的ThreadLocalMap 对象，然后往这个map中插入一条记录，key 其实是ThreadLocal对象，value是各自的set方法传进去的值。  
也就是每个线程其实都有一份自己独享的 ThreadLocalMap对象，该对象的 Key 是 ThreadLocal对象，值是用户设置的具体值。  
在线程结束时可以调用 ThreadLocal.remove()方法，这样会更快释放内存，不调用也可以，因为线程结束后也可以自动释放相关的ThreadLocal变量。

## ThreadLocal的方法 ##

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

# 笔试题 #

1.  如何解决多线程之间线程安全问题?  
    使用多线程之间同步synchronized或使用锁(lock)。
2.  为什么使用线程同步或使用锁能解决线程安全问题呢？  
    将可能会发生数据冲突问题(线程不安全问题)，只能让当前一个线程进行执行。代码执行完成后释放锁，让后才能让其他线程进行执行。这样的话就可以解决线程不安全问题。
3.  什么是多线程之间同步？  
    当多个线程共享同一个资源,不会受到其他线程的干扰。
4.  同步函数使用的是什么锁？  
    同步函数使用this锁，一个线程使用同步代码块(this明锁),另一个线程使用同步函数。如果两个线程抢票不能实现同步，那么会出现数据错误。
5.  java内存模型和java内存结构？  
    java内存模型是多线程可见性(简称JMM)，JMM决定一个线程对共享变量的写入时,能对另一个线程可见。  
    java内存结构属于jvm中的内存分配。
6.  volatile与synchronized区别？  
    ①volatile轻量级，只能修饰变量。synchronized重量级，还可修饰方法。  
    ②volatile只能保证数据的可见性，不能用来同步，因为多个线程并发访问volatile修饰的变量不会阻塞。  
    synchronized不仅保证可见性，而且还保证原子性，因为，只有获得了锁的线程才能进入临界区，从而保证临界区中的所有语句都全部执行。多个线程争抢synchronized锁对象时，会出现阻塞。