多线程（4）

多线程（4）

同步方法及同步块

由于我们可以通过private关键字来保证数据对象只能被方法访问﹐所以我们只需要针对方法提出一套机制,这套机制就是synchronized关键字，它包括两种用法:synchronized方法和synchronized块.

同步方法:public synchronized void method(int args){}

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

缺陷:若将一个大的方法申明为synchronized将会影响效率

同步块:synchronized (Obj ){}

Obj称之为同步监视器

Obj可以是任何对象﹐但是推荐使用共享资源作为同步监视器

同步方法中无需指定同步监视器﹐因为同步方法的同步监视器就是this,就是这个对象本身,或者是class [反射中讲解]

同步监视器的执行过程：

1. 第一个线程访问,锁定同步监视器﹐执行其中代码。
2. 第二个线程访问,发现同步监视器被锁定,无法访问。
3. 第一个线程访问完毕,解锁同步监视器.
4. 第二个线程访问,发现同步监视器没有锁,然后锁定并访问

三个不安全线程案例的修改

买票只有一个对象，直接在方法中添加synchronized即可（代码三十行）

package thread.Syn;

//不安全的买票
//线程不安全，有不在预期中的数出现
public class UnsafeBuyTicket {
    public static void main(String[] args) {
        BuyTicket buyTicket = new BuyTicket();
        new Thread(buyTicket,"小明").start();
        new Thread(buyTicket,"小红").start();
        new Thread(buyTicket,"黄牛").start();

    }
}

class BuyTicket implements Runnable{
    private int ticketNums = 10;
    boolean flag = true;
    @Override
    public void run() {
        while (flag){
            try {
                buy();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    //synchronized同步方法，锁的是this
    private synchronized void buy() throws InterruptedException {
        if (ticketNums<=0){
            flag = false;
            return;
        }
        Thread.sleep(100);
        System.out.println(Thread.currentThread().getName()+"抢到了第"+ticketNums--+"张票");
    }
}

对于取钱案例，synchronized默认锁的对象是this，这里使用方法不适用，可以使用第二种：同步代码块，synchronized(){}其中()内加需要锁的对象，并将方法内容全部丢进代码块中即可

package thread.Syn;

//不安全的取钱实例
public class UnsafeBank {
    public static void main(String[] args) {
        Account account = new Account(100,"创业基金");

        Bank i = new Bank(account,50,"你");
        Bank myWife = new Bank(account,100,"老婆");

        i.start();
        myWife.start();
    }
}

//账户
class Account{
    int money;
    String name;

    public Account(int money, String name) {
        this.money = money;
        this.name = name;
    }
}

//银行：模拟取款
class Bank extends Thread{
    //账户
    Account account;
    //取了多少钱
    int drawingMoney;
    //还有多少钱
    int nowMoney;

    public Bank(Account account, int drawingMoney, String name) {
        super(name);
        this.account = account;
        this.drawingMoney = drawingMoney;
    }

    //synchronized 默认锁的是this
    @Override
    public void run() {

        synchronized (account){
            //判断有没有钱
            if (account.money-drawingMoney<0){
                System.out.println(Thread.currentThread().getName()+"你没有这么多钱，取不了");
                return;
            }
            //sleep();放大问题发生的可能性
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //现有余额 = 原有余额 - 取走的钱
            account.money = account.money-drawingMoney;
            //你手里的钱
            nowMoney = nowMoney+drawingMoney;

            System.out.println(account.name+"余额为："+account.money);
            //Thread.currentThread().getName() = this.getName()
            System.out.println(this.getName()+"手里的钱为："+nowMoney);
        }
    }

}

List与取钱案例类似，用同步代码块在lambda代码块中进行

CopyOnWriteArrayList

一个安全的List类，相当于不安全的List用同步方法锁住，两种达到的效果是一样的

package thread.Syn;

import java.util.concurrent.CopyOnWriteArrayList;

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

死锁

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

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

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

上面列出了死锁的四个必要条件，我们只要想办法破其中的任意一个或多个条件就可以避免死锁发生

死锁案例

package thread.Syn;

//死锁：多个线程互相持有对方需要的资源，形成僵持
public class DeadLock {
    public static void main(String[] args) {
        Makeup g1 = new Makeup(0,"大美女");
        Makeup g2 = new Makeup(1,"小美女");
        g1.start();
        g2.start();
    }
}

//口红
class RedLip{

}

//镜子
class Mirror{

}

class Makeup extends Thread {
    //需要的资源只有一份，用static来保证只有一份
    static RedLip redLip = new RedLip();
    static Mirror mirror = new Mirror();

    int choice;//选择
    String girlName;//使用化妆品的人

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

    @Override
    public void run() {
        //化妆
        try {
            makeup();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    //化妆，互相持有对方的锁，就是需要拿到对方的资源
    private void makeup() throws InterruptedException {
        if (choice == 0) {
            synchronized (redLip) {//获得口红的锁
                System.out.println(this.girlName + "获得口红的锁");
                Thread.sleep(1000);

                synchronized (mirror) {//一秒钟后想获得镜子的锁
                    System.out.println(this.girlName + "获得镜子的锁");
                }
            }
        } else {
            synchronized (mirror) {//获得镜子的锁
                System.out.println(this.girlName + "获得镜子的锁");
                Thread.sleep(2000);

                synchronized (redLip) {//二秒钟后想获得口红的锁
                    System.out.println(this.girlName + "获得口红的锁");
                }
            }
        }
    }
}

破解死锁方法：将第一个锁下面的第二个锁拿出来即可