java基础(3)——多线程(3)线程同步

线程同步（重点）

多个线程操作同一个资源

并发：同一个对象被多个线程同时操作

处理多线程问题时，多个线程访问同一个对象，并且某些线程还想修改此对象，这式就需要线程同步，线程同步其实就是一种等待机制，多个需要同时访问此对象的线程进入这个对象的对象等待池形成队列。等待前面的线程使用完毕，下一个线程再使用

同步的条件：队列+锁

由于同一个进程的多个线程访问同一块存储空间，在带来方便的同时，也带来了访问的冲突问题，为了确保数据的正确访问，在访问时加入锁机制synchronized，当一个线程获得对象的排他锁，独占资源，其他线程必须等待，释放锁以后即可访问，但存在的问题：

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

在不安全情况的例子

例子： 抢票

//不安全的买票情况
public class UnsafeBuy {
    public static void main(String[] args) {
        BuyTickets buyTickets = new BuyTickets();
        new Thread(buyTickets, "me").start();
        new Thread(buyTickets, "you").start();
        new Thread(buyTickets, "he").start();
    }
}
class BuyTickets extends Thread{
    private int num = 10;//10张票

    @Override
    public void run() {
        while (num > 0){
            try {
                //放大问题发生性
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "抢到第" + num-- + "张票");
        }
    }
}

例子： 取钱

public class UnsafeBank {
    public static void main(String[] args) {
        Account account = new Account(100, "money");//账户一共100

        Bank me = new Bank(account, 50, "me");//一共取了150
        Bank you = new Bank(account, 100, "you");

        me.start();
        you.start();
    }
}
//账户
class Account{
    int money;
    String name;

    public Account(int money, String name) {
        this.money = money;
        this.name = name;
    }
}
//银行
class Bank extends Thread{
    private int getMoney;//取走的钱
    private String name;//去取钱人
    private Account account;
    public Bank(Account account, int getMoney, String name) {
        super(name);//this.getName()==Thread.currentThread().getName()
        this.account = account;
        this.getMoney = getMoney;
    }

    @Override
    public void run() {
        int haveMoney = 0;
        if (account.money < getMoney){
            System.out.println(this.getName() + "钱不够");
            return;
        }
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        account.money = account.money - getMoney;
        haveMoney = getMoney + haveMoney;
        System.out.println(Thread.currentThread().getName() + "取走" + getMoney);
    }
}

例子： 线程不安全

//线程不安全
public class UnsafeList {
    public static void main(String[] args) throws InterruptedException {
        List<String> list = new ArrayList<>();
        for (int i = 0; i < 10000; i++) {
            new Thread(()->{
                list.add(Thread.currentThread().getName());//实际没有1000
            }).start();
        }
        System.out.println(list.size());
    }
}

同步方法、同步代码块

通过synchronized关键字实现

synchronized方法控制对“对象”的访问，每个对象都有一把锁，每个synchronized方法都要获得此锁才能执行，否则会阻塞，方法一旦执行，就独占该锁，直到释放，后面阻塞的线程才能执行

但是将一个大方法声明为synchronized同步方法会影响效率

同步块：synchronized（obj）{}

• obj称为同步监视器
• 可以是任何对象，但推荐使用共享资源作为同步监视器
• 同步方法不需同步监视器，因为同步方法的同步监视器就是this，就是这个对象本身，或者式class

在安全情况的例子

例子： 抢票

public class UnsafeBuy {
    public static void main(String[] args) {
        BuyTickets buyTickets = new BuyTickets();

        new Thread(buyTickets, "me").start();
        new Thread(buyTickets, "you").start();
        new Thread(buyTickets, "he").start();
    }
}
class BuyTickets extends Thread{
    private int num = 10;//10张票

    @Override
    public synchronized void run() {
        while (num > 0){
            try {
                //放大问题发生性
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "抢到第" + num-- + "张票");
        }
    }
}

例子： 取钱

public class UnsafeBank {
    public static void main(String[] args) {
        Account account = new Account(100, "money");

        Bank me = new Bank(account, 50, "me");
        Bank you = new Bank(account, 100, "you");

        me.start();
        you.start();
    }
}
//账户
class Account{
    int money;
    String name;

    public Account(int money, String name) {
        this.money = money;
        this.name = name;
    }
}
//银行
class Bank extends Thread{
    private int getMoney;//取走的钱
    private String name;//去取钱人
    private Account account;
    public Bank(Account account, int getMoney, String name) {
        super(name);//this.getName()==Thread.currentThread().getName()
        this.account = account;
        this.getMoney = getMoney;
    }

    @Override
    public void run() {
        synchronized (account){
            int haveMoney = 0;
            if (account.money < getMoney){
                System.out.println(this.getName() + "钱不够");
                return;
            }
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            account.money = account.money - getMoney;
            haveMoney = getMoney + haveMoney;
            System.out.println(Thread.currentThread().getName() + "取走" + getMoney);
        }
    }
}

例子： 线程安全

public class UnsafeList {
    public static void main(String[] args) throws InterruptedException {
        List<String> list = new ArrayList<>();
        for (int i = 0; i < 10000; i++) {
            new Thread(()->{
                synchronized (list) {
                    list.add(Thread.currentThread().getName());
                }
            }).start();
        }
        Thread.sleep(100);
        System.out.println(list.size());
    }
}

//测试JUC安全类型的集合
public class TestJUC {
    public static void main(String[] args) {
        CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();
        for (int i = 0; i < 1000; i++) {
            new Thread(()->{
                list.add(Thread.currentThread().getName());
            }).start();
        }
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(list.size());
    }
}

死锁

多个线程各自占有一些共享资源，并且相互等待其他线程占用的资源才能运行，而导致两个或者多个线程都在等待对方释放资源，都停止执行的情况，某一同步块同时拥有“两个以上对象的锁”时，就可能发送死锁的问题

产生死锁的必要条件：

• 互斥条件：一个资源只能被一个进程使用
• 请求与保持：一个进程至少保持一个资源的同时请求其他资源，但此资源还保持不释放
• 不剥夺条件：进程已获得的资源在没有使用完毕前，不能强行剥夺
• 循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系

public class DeadLock {
    public static void main(String[] args) {
        Makeup me = new Makeup(0, "me");
        Makeup you = new Makeup(1, "you");

        me.start();
        you.start();
    }
}
//口红
class Lipstick{}
//镜子
class Mirror{}
//化妆
class Makeup extends Thread{
    //都只有一份
    static Lipstick lipstick = new Lipstick();
    static Mirror mirror = new Mirror();

    int choice;
    String name;
    public Makeup(int choice, String name){
        this.choice = choice;
        this.name = name;
    }
    @Override
    public void run() {
        if (choice == 0){
            synchronized (lipstick){//获得口红
                System.out.println(name + "获得口红的锁");
                synchronized (mirror){//在没有释放口红时又想获得镜子
                    System.out.println(name + "获得镜子的锁");
                }
            }
        }else {
            synchronized (mirror){//获得镜子
                System.out.println(name + "获得镜子的锁");
                synchronized (lipstick){//在没有释放镜子时又想获得口红
                    System.out.println(name + "获得口号的锁");
                }
            }
        }
    }
}

Lock

• 从jdk5.0开始，可以通过显示定义同步锁对象来实现同步，同步锁使用lock对象充当
• java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供和了对共享资源的独占访问，每次只能由一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象
• ReentrantLock类实现了Lock，拥有和synchronized相同的并发性和内存语义，在实现线程的控制中，比较常用的是ReentrantLock，可以实现加锁，解锁

public class TestLock {
    public static void main(String[] args) {
        BuyTickets buyTickets = new BuyTickets();

        new Thread(buyTickets).start();
        new Thread(buyTickets).start();
        new Thread(buyTickets).start();
    }
}
class BuyTickets implements Runnable{
    int num = 10;
    private final ReentrantLock lock = new ReentrantLock();//定义一个可重入锁
    @Override
    public void run() {
        try{
            lock.lock();//加锁
            while (num > 0){
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(num--);
            }
        }finally {
            lock.unlock();//解锁
        }
    }
}

synchronized与Lock的对比

• Lock是显示锁，手动开启和关闭，synchronized是隐式锁，出了作用域自动释放
• Lock只有代码块锁，synchronized由代码块锁和方法锁
• 使用Lock，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性
• 优先使用顺序
  • Lock->同步代码块->同步方法

如有不对的地方欢迎指出，共同进步！