多线程的安全问题及解决方案

概念

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

解决方案

核心思想：同一个时刻保证只允许单线程执行

方案

1. 使用java锁的机制Synchronized、Lock锁和CAS无锁机制
2. 对于代码中如果在多线程同时执行操作的情况下，可能会受到其他线程的干扰的代码采用锁的机制，在同一个时刻只能保证只有一个线程去执行，只有获取到锁之后，才能够进入该代码块执行，代码执行完之后释放锁之后其他线程去获取锁才可以执行。
3. 没有获取到锁的线程，则一直会排队阻塞，整个过程是一个悲观状态

Synchronized的基本用法

可以定义任意对象作为锁，但是需要注意：如果该方法为普通方法的情况下，可以使用普通对象或者属性作为锁
如果该方法为静态方法的情况，则必须使用当前类的Class或者是静态属性作为锁
实例方法
如果在普通方法上加上锁，则默认表示使用this锁
静态代码块
如果是在静态方法上加上锁，则默认表示使用当前类的.class锁。

锁的重入锁

package com.mayikt;

public class Thread006 implements Runnable {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + ",我是子线程");
        a();
    }

    public synchronized void a() {
        System.out.println(Thread.currentThread().getName() + ",我是方法A");
        //调用b方法获取锁的时候可以之间获取this对象了
        b();
    }

    public synchronized void b() {
        System.out.println(Thread.currentThread().getName() + ",我是方法B");
    }
}

多线程死锁产生的原因

在同步中嵌套同步，你中有我，我中有你，会出现死锁的现象

Lock锁的基本用法

在使用阻塞等待获取锁的方式中，必须在try代码块之外，并且加锁方法和try代码块之间没有任何可能抛出异常的方法调用，避免加锁成功后，在finally无法解锁
说明一：如果在lock方法与try代码块之间的方法调用抛出异常，那么无法解锁，造成其他线程无法成功获取锁
说明二：如果lock方法在try代码块之内，可能由于抛出异常，导致在finally代码块中，unlock对未加锁的对象解锁，它会调用tryRelease，抛出IlegalMonitorStateException异常
说明三：在Lock对象的lock方法实现中可能抛出uncheck异常
lock加锁的代码

    private  void ticket() {
        if (count > 0) {
            try {
                Thread.sleep(30);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            lock.lock();
            try {
                System.out.println(Thread.currentThread().getName() + "正在出第" + (101 - count) + "张票");
                count--;
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }

    }

读写锁ReadAndWriteLock

代码例子。

package com.mayikt;

import java.util.concurrent.locks.ReentrantReadWriteLock;

public class MyTask {
    ReentrantReadWriteLock lock = new ReentrantReadWriteLock();

    /**
     * 读读共享
     */
    public void read() {
        lock.readLock().lock();
        try {
            System.out.println(Thread.currentThread().getName() + ",正在开始读取");
            Thread.sleep(1000);
            System.out.println(Thread.currentThread().getName() + ",正在结束读取");
        } catch (Exception e) {

        }

        lock.readLock().unlock();
    }

    /**
     * 写写互斥
     */
    public void write() {
        lock.writeLock().lock();
        try {
            System.out.println(Thread.currentThread().getName() + ",正在开始写入");
            Thread.sleep(1000);
            System.out.println(Thread.currentThread().getName() + ",正在结束写入");
        } catch (Exception e) {

        }
        lock.writeLock().unlock();

    }

    public static void main(String[] args) {
        MyTask myTask = new MyTask();
/*        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                myTask.write();
            }).start();
        }*/
      for (int i =0; i <10;i++){
          new Thread(() -> {
              myTask.read();
          }).start();
          new Thread(() -> {
              myTask.write();
          }).start();
      }
    }
}

Lock与Synchronized锁的区别

1. Synchronized属于java内置的关键字，而lock锁是基于aqs封装的一个锁的框架
2. Synchronized当代码执行结束自动释放锁，而lock需要人工释放锁，相对于lock锁更加灵活
   参考：蚂蚁课堂