线程的锁机制和解决线程同步问题的方法_同步线程解决的问题 (synchronized、同步锁)

线程的安全问题

多个线程同时访问一个资源（变量、代码块、数据等），可能出现线程同步问题。

多个线程的执行是抢占式的，一个线程在执行一系列程序指令中途时，就被其它线程抢占，可能导致数据状态出现问题。

解决方式：锁机制

锁机制

synchronized 关键字，实现锁机制，可以用于修饰方法或代码块，提升数据的安全性，降低性能。

synchronized的原理：

通过监视器（monitor）完成

当对方法或一段代码上锁后，会启动监视器对这段代码监控，监视器中有计数器，当计数器为0时，允许线程进入，线程进入后，计数器加1，其它线程访问时，计数器不为0，不允许线程进入，线程执行完代码块后，计数器减1为0 ，监视器允许其它线程进入。

同步方法

当第一个线程进入方法后，自动上锁，其它线程访问不了，前面线程执行完方法后，自动释放锁，其它线程就可以访问。

public synchronized 修饰符 方法名(...){
	...
}

同步代码块

synchronized(锁对象){
	....
	....
}

锁对象的要求：

        1.任意的Java对象都可以作为锁

        2. 不能是局部变量

疑问：同步方法和同步代码块的区别？

解答：

1.语法不同，一个写在方法上，一个写在方法内部

2.锁粒度不同，同步方法作用于整个方法，同步代码块作用于一段代码

3.性能不同，同步方法低于同步块

4.锁对象不同，同步方法是固定的，静态就是类.class，非静态的就是this

同步代码块可以指定锁对象。

手写一个简单的线程安全的单例模式

 
/**
 * 懒汉式
 */
public class LazySingleton {
    //创建一个锁对象
    private static Lock lock = new ReentrantLock();
    //2.定义静态实例 加volatile的目的是禁止指令重排，从而得到一个没有初始化的对象
    private static volatile LazySingleton singleton = null;
 
    //1.私有的构造方法
    private LazySingleton() {
        System.out.println("懒汉式创建对象");
        try {
            Thread.sleep(300);
        } catch (InterruptedException e) {
 
            e.printStackTrace();
        }
    }
 
    //3.静态方法创建对象并返回
    public synchronized static LazySingleton getInstance() {
        //双检索，DCL double check lock
        //提升性能，不为空，就不执行同步代码块
        if(singleton==null){
            //同步代码块
            synchronized (LazySingleton.class){
                //判断是否为空，再创建，整体执行
                if(singleton==null){
                    singleton = new LazySingleton();
                }
            }
        }
        return singleton;
    }
}

同步锁

在并发包 java.concurrent.lock下存在大量的锁

Lock接口

常用的方法：

lock() //上锁
unlock() //解锁

常见的实现类：

ReentrantLock //重入锁
 
ReadLock   //读锁
 
WriterLock  //写锁

简单应用：

//构造方法如果带参数，表示是否是公平锁
Lock lock = new ReentrantLock(); //成员变量
 
//方法内：
try{
	lock.lock();
	同步的代码
}finally{
	lock.unlock();
}

公平锁和非公平锁的区别？

公平锁：等待锁时间长的线程，更容器获得锁。

非公平锁：等待锁时间长和短的线程，获得锁几率相同。

synchronized和同步锁的区别？

上锁：synchronized是自动上锁和解锁，同步锁是手动完成的。

性能：同步锁的性能高于synchronized。

使用：synchronized使用简单，功能单一，同步锁提供更多方法，使用灵活。

粒度： 同步方法 > 同步块/同步锁

性能： 同步锁 > 同步块 > 同步方法

方便： 同步方法 > 同步块 > 同步锁

手写一个简单的线程死锁案例

 
/**
 * 线程死锁案例
 * 有两个线程，两个锁，线程A持有锁B，需要锁A；线程B持有锁A，需要锁B；
 */
public class DieLock {
 
    private static Lock a = new ReentrantLock();
    private static Lock b = new ReentrantLock();
 
    public void testA() throws InterruptedException {
        synchronized (a){
            System.out.println(Thread.currentThread().getName()+"有a锁,需要b锁");
            Thread.sleep(300);
            synchronized (b){
                System.out.println(Thread.currentThread().getName()+"有a锁,b锁");
            }
        }
    }
    public void testB() throws InterruptedException {
        synchronized (b){
            System.out.println(Thread.currentThread().getName()+"有b锁,需要a锁");
            Thread.sleep(300);
            synchronized (a){
                System.out.println(Thread.currentThread().getName()+"有a锁,b锁");
            }
        }
    }
 
    public static void main(String[] args) {
        DieLock dieLock = new DieLock();
        new Thread(()->{
            try {
                dieLock.testA();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
        new Thread(()->{
            try {
                dieLock.testB();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
    }
}

volatile关键字

线程同步有三大特性：

1.原子性（一系列指令要么全部执行，要么全部不执行）。

2.可见性（线程中的数据修改后，其它线程也可以读取最新的数据）。

3.有序性（线程中的指令按顺序执行，不会出现乱序）。

volatile用于修饰成员变量，保证变量的可见性和有序性。

原子性

一段代码作为整体执行，不会被其它线程打断，可以通过锁机制保证。

可见性

 

多线程的执行过程中，每个线程有自己的工作内存，线程会从主内存中加载数据到工作内存中，修改工作内存的数据后，其它线程是看不到最新的数据的，直到线程将新数据写回到主内存为止，中间存在线程间数据不一致的问题。

解决方法：变量前加volatile

变量前加上volatile，保证可见性，线程在修改此变量时，是在主内存中直接进行修改，其它线程马上可以看到，不存在数据不一致的情况。

有序性

cpu为了提高程序执行的效率，可能对指令顺序进行重排，volatile可以禁止指令重排。

synchronized和volatile的区别

修饰的对象：synchronized修改代码块或方法，volatile只能修饰变量。

保证的特性：synchronized保证原子性、可见性；volatile不能保证原子性，保证可见性和有序性。

性能：volatile是轻量级的线程同步方式，性能更高。

原子类

并发包中提供了一系列原子类，可以保证数据操作的原子性。这里简单举一个AtomicInteger原子整数的例子。

 
/**
 * 原子类
 */
public class AtomicDemo {
    private static int count =0;
    //原子整数
    private static AtomicInteger atomicInteger = new AtomicInteger(0);
    public static void main(String[] args) {
        for (int i = 0; i < 10000 ; i++) {
            new Thread(()->{
                //1.加载count值
                //2.计算count++
                //3.将新的值传给count
//                count++;
                //原子自增
               atomicInteger.getAndIncrement();
            }).start();
        }
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        System.out.println(count);
        System.out.println(atomicInteger.intValue());
    }
}

乐观锁和悲观锁的区别？

悲观锁：比较悲观，认为线程同步问题会经常出现，倾向于给资源上锁。

乐观锁：比较乐观，认为线程同步问题不会常出现，不给资源上锁，通过其它方式解决。

版本号机制，对数据设置版本，每次修改后版本会更新，修改后将版本和前面版本进行比较，相同就提交，不同就不提交。

CAS机制，CompareAndSwap：通过内存偏移量获得数据的原始值，通过原始值计算出预期的值，将预期的值和实际的值进行比较，相同就更新，否则就不更新进入循环等待状态，直到比较相等。

如果线程的竞争比较激烈，应该使用悲观锁。线程竞争不强的时候，使用乐观锁。