线程同步

线程同步

多线程操作同一份资源，并发

其实就是一种等待机制，多个需要同时访问此对象的线程进入这个对象的等待池，形成对列，等待前面线程使用完毕，下一个线程再使用

队列和锁

为了解决线程的安全性

为了保证数据在方法中被访问时的正确性，在访问时加入锁机制synchronized，当一个线程获得对象的排它锁，独占资源时，其他线程必须等待

存在以下问题：

• 一个线程持有锁会导致其他所有需要此锁的线程挂起
• 在多线程竞争下，加锁，释放锁会导致较多的切换与调度延时，引起性能问题
• 如果一个优先级高的线程等待一个优先级低的线程释放锁，会导致优先级倒置，引起性能问题

同步方法

synchronized方法控制对”对象“的访问，每个对象对应一把锁，每个synchronized方法都必须获得调用该方法的对象的锁才能执行，否则线程会阻塞，方法一旦执行，就独占该锁，直到该方法返回才释放，后面被阻塞的线程才能获得这个锁，继续执行

synchronized同步的是对象本身

同步块

synchronized( Obj ){}

Obj 称为同步监视器

• Obj可以为任意对象，但是推荐使用共享资源作为同步监视器
• 同步方法中无需指定同步监视器，因为同步方法中的同步监视器就是this，就是这个对象本身，或者是class

import java.util.ArrayList;

public class TestUnsafeList {
    public static void main(String[] args) throws InterruptedException {
        ArrayList list = new ArrayList();

        for (int i = 0; i < 1000; i++) {
            new Thread(()->{
                synchronized (list) {
                    list.add(Thread.currentThread().getName());
                }
            }).start();

        }Thread.sleep(100);
        System.out.println(list.size());
    }
}

死锁

某一个同步块同时拥有”两个以上对象的锁“时，就可能会发生”死锁“的问题

产生死锁的四个必要条件：

1. 互斥条件：一个资源每次只能被一个进程使用
2. 请求与保持条件：一个进程因请求资源而阻塞时，对以获得的资源保持不放
3. 不剥夺条件：进程已获得的资源，在未使用完之前，不能强行剥夺
4. 循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系

package com.syzCodeGround.Demo05_Synchronized;


// 死锁：多个线程互相持有对象需要的资源，然后形成僵持
public class DeadLock {
    public static void main(String[] args) {
        Makeup girl1 = new Makeup(0,"Cinderalla");
        Makeup girl2 = new Makeup(1,"White");
        girl1.start();
        girl2.start();
    }
}


class LipStick{

}

class Mirror{

}

class Makeup extends Thread{
    static private LipStick lipStick = new LipStick();
    static private Mirror mirror = new Mirror();
    private String girlName;
    private int choice;

     Makeup(int choice,String girlName)  {
        this.choice = choice;
        this.girlName = girlName;

    }

    public void makeUp() throws InterruptedException {
        if(choice == 0){
            synchronized(lipStick){
                System.out.println(girlName+"gets a lipStick");
                Thread.sleep(1000);
                // 这样是行不通的，锁不能嵌套,否则会卡死
//                synchronized(mirror){
//                    System.out.println(girlName+"gets a Mirror");
//                }
            }
            synchronized(mirror){
                System.out.println(girlName+"gets a mirror");
            }
        }
        else {
            synchronized(mirror){
                System.out.println(girlName+"gets a Mirror");
                Thread.sleep(1000);
            }
            synchronized(lipStick){
                System.out.println(girlName+"gets a lipStick");
            }
        }
    }

    @Override
    public void run() {
        try {
            makeUp();
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }
}

Lock（锁）