Java学习路线-15：多线程的同步与死锁

第3 章 ： 线程的同步与死锁 14 同步问题引出

Thread描述每一个线程对象 Runnable描述多个线程操作的资源 多个线程访问同一资源的时候，如果处理不当会产生数据错误

3个线程卖票程序，会出现多张同号的票

class MyThread implements Runnable {
    private int ticket = 10;

    @Override
    public void run() {
        while (true) {
            if (this.ticket > 0) {
                System.out.println(
                        Thread.currentThread().getName()
                                + "卖第" + this.ticket + " 张票"
                );
                this.ticket--;

            } else {
                System.out.println("票卖光了");
                break;
            }
        }
    }
}

public class Demo {
    public static void main(String[] args) {
        MyThread thread = new MyThread();
        new Thread(thread).start();
        new Thread(thread).start();
        new Thread(thread).start();
        // 5
    }
}

15 线程同步处理

同步：多个操作在同一时间段内只能有一个线程进行， 其他线程要等待此线程完成之后才可以继续还行

解决同步问题的方式是锁 synchronized定义同步方法或同步代码块，里边的代码只允许一个线程执行

加入同步之后，程序整体性能下降了

1、同步代码块

synchronized(同步对象){}

举例

synchronized (this) {
    if (this.ticket > 0) {
        System.out.println(Thread.currentThread().getName() +
                "卖第" + this.ticket + " 张票");
        this.ticket--;

    } else {
        System.out.println("票卖光了");
        break;
    }
}

2、同步函数

public synchronized boolean method(){}

举例

public synchronized boolean sale(){
    if (this.ticket > 0) {
        System.out.println(Thread.currentThread().getName() +
                "卖第" + this.ticket + " 张票");
        this.ticket--;
        return true;
    } else {
        System.out.println("票卖光了");
        return false;
    }
}

16 线程死锁

死锁是在进行多线程同步处理之中有可能产生的一种问题 是指若干个线程彼此互相等待的状态

若干线程访问同一资源时，一定要进行同步处理 而过多的同步会造成死锁

public class Demo {

    public static void main(String[] args) {
        //o1 o2 代表资源
        Object o1 = new Object();
        Object o2 = new Object();

        System.out.println("go go go!");

        Thread t1 = new Thread(new Runnable() {
            public void run() {
                synchronized (o1) {   //线程t1获取o1的锁才能继续执行
                    try {
                        Thread.sleep(3000);      //睡3秒，确保线程t2把o2锁拿走
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("t1获得了哦O1");
                    synchronized (o2) {                 //线程t1获取o2的锁才能继续执行
                        System.out.println("t1获得了哦O2");
                    }
                }
            }
        });

        Thread t2 = new Thread(new Runnable() {
            public void run() {
                synchronized (o2) {  //线程t2获取o2的锁才能继续执行
                    try {
                        Thread.sleep(3000);     //睡3秒，确保线程t1把o1锁拿走
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("t2获得了哦O2");
                    synchronized (o1) {             //线程t2获取o1的锁才能继续执行
                        System.out.println("t2获得了哦O1");
                    }
                }
            }
        });

        t1.start();
        t2.start();       //启动线程
    }

}

第4 章 ： 综合实战：“生产者-消费者”模型 17 生产者与消费者基本程序模型

生产者负责信息内容生产 消费者取走信息

消费者要等待生产者生产完成再取走 生产者需要等待消费者消费完成再生产

不加锁示例

class Message {
    private String content;

    public void setContent(String content) {
        this.content = content;
    }

    public String getContent() {
        return content;
    }
}

class Producer implements Runnable {
    private Message message;
    private static int count;

    public Producer(Message message) {
        this.message = message;
    }

    @Override
    public void run() {
        for (int i = 0; i