多线程之基础篇07：线程的同步机制

最新推荐文章于 2021-07-17 23:12:02 发布

Japson_z

最新推荐文章于 2021-07-17 23:12:02 发布

阅读量506

点赞数

分类专栏：多线程的进击：从基础到高级文章标签：多线程线程

本文链接：https://blog.csdn.net/japson_iot/article/details/79588960

版权

多线程的进击：从基础到高级专栏收录该内容

17 篇文章 0 订阅

订阅专栏

多线程之基础篇07：线程的同步机制

标签：多线程

多线程之基础篇07线程的同步机制

卖票的问题

我们在之前写三个窗口卖票的问题时，所写的代码是有问题的。虽然当时我们运行的结果是对的，但是不代表它是正确的。我们可以在每一个线程执行前sleep()10毫秒再运行，就可以将这个错误放大：

package charThread;

class Window2 implements Runnable {
    int ticketsCount = 5;
    public void run() {
        while (ticketsCount > 0) {
        //睡眠10毫秒，放出CPU资源
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            ticketsCount --;    //如果还有票就卖出一张
            System.out.println(Thread.currentThread().getName() + "窗口已经售出一张，剩余票数" + ticketsCount);
        }
    }
}
public class TicketsThread2 {
    public static void main(String[] args) {
        Window2 w = new Window2();

        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);
        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();

    }
}

输出结果：

窗口3窗口已经售出一张，剩余票数2
窗口1窗口已经售出一张，剩余票数2
窗口2窗口已经售出一张，剩余票数2
窗口1窗口已经售出一张，剩余票数1
窗口3窗口已经售出一张，剩余票数0
窗口2窗口已经售出一张，剩余票数1

车站一共只有5张车票，但是三个窗口居然出了6张车票！

线程的安全问题

出现的问题的原因

我们可以看到上面的代码是存在线程的安全问题的：打印车票时会出现重票、错票等：

我们所期待的理想状况是：

此处输入图片的描述

但是我们将错误放大时，会出现下面这样的极端：

此处输入图片的描述

这就导致了出现了安全问题。

当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完，另一个线程参与进来执行。导致共享数据的错误。

解决方法

必须让一个线程操作共享数据完毕以后，其他线程才有机会参与共享数据的操作。

在Java中引入了线程同步机制来实现线程的安全：

方式一：同步代码块

实现Runnable接口的方法

synchronized (同步监视器）{
          // 需要被同步的代码（即为操作共享数据的代码）；
    }

共享数据：多个线程共同操作的同一个数据（变量）；
同步监视器：由任何一个类的对象来充当。哪个线程获取此监视器，谁就执行大括号里被同步的代码（锁）,且要求所有的线程共用同一把锁；

添加同步代码块后：

class Window2 implements Runnable {
    int ticketsCount = 5;   //共享数据


    public void run() {
        //操作共享数据的代码，用synchronized关键字同步代码块
        //任何一个类的对象，用来充当同步监视器，即锁
        //这里使用的是this代表当前线程对象来当锁
         while (true) {
            synchronized (this) {
                if (ticketsCount > 0) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    ticketsCount--;    //如果还有票就卖出一张
                    System.out.println(Thread.currentThread().getName() + "窗口已经售出一张，剩余票数" + ticketsCount);
                }
            }
        }
    }
}

继承Thread的方法

在实现的方式中，考虑同步的话，可以使用this来充当锁，但是在继承的方式中，要慎用this。比如下面的代码：

class Window1 extends Thread {
    static int ticketsCount = 5;  //一共有5张火车票
    public void run() {
        synchronized (this) {
            while (ticketsCount > 0) {
                try {
                    Thread.sleep(10);   //证明了sleep()不会释放锁！！！
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                ticketsCount--;    //如果还有票就卖出一张
                System.out.println(Thread.currentThread().getName() + "窗口已经售出一张，剩余票数" + ticketsCount);
            }
        }
    }
}

输出结果：

窗口3窗口已经售出一张，剩余票数4
窗口2窗口已经售出一张，剩余票数4
窗口1窗口已经售出一张，剩余票数4
窗口2窗口已经售出一张，剩余票数3
窗口3窗口已经售出一张，剩余票数3
窗口1窗口已经售出一张，剩余票数3
窗口2窗口已经售出一张，剩余票数2
窗口3窗口已经售出一张，剩余票数2
窗口1窗口已经售出一张，剩余票数2
窗口3窗口已经售出一张，剩余票数-1
窗口1窗口已经售出一张，剩余票数-1
窗口2窗口已经售出一张，剩余票数-1

可以看到，我们确实是用synchronized关键字和this对象来进行了处理，但是并没有达到我们的与其效果。

这是因为synchronized关键字的目的是为了让当前线程获取同步监视器，但是我们要知道，由于我们使用的是继承Thread类，那么我们在主函数中是为每一个线程都创建一个对象，这不同于使用实现Runnable接口，每个子线程都共用一个对象。因此我们在上面的代码中使用this的话，this表示w1,w2,w2三个子线程的对象，那就相当于每一个子线程都有各自的一把锁，那就失去意义了。

因此我们要使用以下代码：

class Window1 extends Thread {
    static int ticketsCount = 5;  //一共有5张火车票
    static Object obj = new Object();   //使用static对象来充当锁
    public void run() {
        while (true) {
            synchronized (obj) {
                if (ticketsCount > 0) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    ticketsCount--;    //如果还有票就卖出一张
                    System.out.println(Thread.currentThread().getName() + "窗口已经售出一张，剩余票数" + ticketsCount);
                }
            }
        }
    }
}

注意：

我们要明确“共享代码”到底是谁，不要多也不要少！

注意：

上面的方法我是按照老师讲的写的，但是我在运行时发现一个问题，这三个线程中的while()循环都是死循环，即使没有数据可处理了，run方法也没有结束，因此我添加了一个判断，break出while循环，这样线程就可以执行完了。

    public void run() {
        while (true) {
            synchronized (obj) {
                if (ticketsCount > 0) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    ticketsCount--;    //如果还有票就卖出一张
                    System.out.println(Thread.currentThread().getName() + "窗口已经售出一张，剩余票数" + ticketsCount);
                }
                if (ticketsCount == 0) {
                    System.out.println("STOP!!!");
                    break;
                }
            }
        }
    }

方式二同步方法

将操作共享数据的方法声明为synchronized，此方法为同步方法，能够保证当其中一个线程执行此方法时，其他线程在在外等待，直到此线程执行完。

相对于同步代码块显式的写出锁，同步方法也有锁，是this，但是没有显式的表示出来。

实现Runnable接口的方法

package charThread;

class Window2 implements Runnable {
    int ticketsCount = 100;   //共享数据

    public void run() {
        while (true) {
            show();
            if (ticketsCount == 0) {
                System.out.println("STOP!!!");
                break;
            }
        }
    }
    //同步方法
    public synchronized void show() {
        if (ticketsCount > 0) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            ticketsCount--;    //如果还有票就卖出一张
            System.out.println(Thread.currentThread().getName() + "窗口已经售出一张，剩余票数" + ticketsCount);
        }
    }
}

继承Thread的方法

我们先试着写一下：

package charThread;

/**
 * Created by japson on 9/7/2017.
 */

class Window1 extends Thread {
    static int ticketsCount = 10;

    public void run() {
        while (true) {
            show();
            if (ticketsCount == 0) {
                System.out.println("STOP!!!");
                break;
            }
        }
    }

    public synchronized void show() {
        if (ticketsCount > 0) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            ticketsCount--;    //如果还有票就卖出一张
            System.out.println(Thread.currentThread().getName() + "窗口已经售出一张，剩余票数" + ticketsCount);
        }
    }
}

运行结果：

窗口1窗口已经售出一张，剩余票数9
窗口3窗口已经售出一张，剩余票数8
窗口2窗口已经售出一张，剩余票数7
窗口3窗口已经售出一张，剩余票数5
窗口1窗口已经售出一张，剩余票数5
窗口2窗口已经售出一张，剩余票数5
窗口1窗口已经售出一张，剩余票数2
窗口2窗口已经售出一张，剩余票数2
窗口3窗口已经售出一张，剩余票数2
窗口3窗口已经售出一张，剩余票数0
窗口1窗口已经售出一张，剩余票数0
STOP!!!
窗口2窗口已经售出一张，剩余票数0
STOP!!!
STOP!!!

我们发现，结果不是我们想要的。

因为我们在同步代码块中学过了，继承Thread类实现了三个子线程对象，每个子线程不共享，有自己的一个锁。synchronized方法中有的是隐式的锁：this对象。因此三个子线程都有各自的this锁，所以同步方法要想用在继承Thread类上，要看this对象是否是唯一的。

线程同步练习

Description

银行有一个账户。有两个储户分别向同一个账户存3000元，每次存1000，存三次。每次存完打印账户余额。

问题：该线程是否有安全问题，如果有如何解决？

提示：
1. 明确那些代码是多线程运行代码，须写入run()方法
2. 明确什么是共享数据
3. 明确多线程运行代码中哪些语句是操作共享数据的

拓展问题：可否实现两个储户交替存钱的操作

Code

实现的方法

package charThread;

class Account {
    double balance;
    public Account() {
    }
    public synchronized void deposit(double money) {
        balance = balance + money;
        try {
            Thread.currentThread().sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("用户" + Thread.currentThread().getName() + "存款1000元，账户余额" + balance);
    }
}

class Customer implements Runnable{
    Account account = new Account();

    public void run() {
        for (int i = 0;i < 3;i++) {
            account.deposit(1000);
        }
    }
}

public class TestAccount {
    public static void main(String[] args) {
        Customer customer = new Customer();
        Thread t1 = new Thread(customer);
        Thread t2 = new Thread(customer);

        t1.setName("甲");
        t2.setName("乙");

        t1.start();
        t2.start();
    }
}

继承的方法

package charThread;

/**
 * Created by japson on 9/10/2017.
 */
class Account1 {
    double balance;

    public Account1() {}
    public synchronized void deposit(double money) {
        balance += money;
        try {
            Thread.currentThread().sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("用户" + Thread.currentThread().getName() + "存款1000元，账户余额" + balance);
    }
}

class Customer1 extends Thread {
    Account1 account1;
    //想要将Account作为共享数据，创建一个Customer的构造方法，并传进参数
    public Customer1(Account1 account1) {
        this.account1 = account1;
    }
    public void run() {
        for (int i = 0;i < 3;i++) {
            account1.deposit(1000);
        }
    }
}


public class TestAccount1 {
    public static void main(String[] args) {
        Account1 account1 = new Account1();
        Thread t1 = new Customer1(account1);
        Thread t2 = new Customer1(account1);

        t1.setName("甲");
        t2.setName("乙");

        t1.start();
        t2.start();
    }
}