线程的同步

Posted crabdumplings

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了线程的同步相关的知识，希望对你有一定的参考价值。

线程的同步

线程的安全问题

  • 多个线程执行的不确定性引起执行的结果的不稳定性
  • 多个线程对数据的共享，会造成操作的不完整性、会破坏数据（例如窗口买票问题，多个窗口对票数进行共享，会出现两个窗口卖号码相同的票给不同的人）

通过同步机制解决线程安全问题

方法一：同步代码块

格式

synchronized(同步监视器){

    需要被同步的代码

    }

举例说明

class Thread implements Runnable{

    private Object obj = new Object();

    public void run() {
        //使用类对象充当锁
        synchronized(obj){
        .......
        }
    }
}

说明

  • 操作共享数据的代码即为需要被同步的代码
    • 不能多包含代码，也不能少包含代码
  • 共享数据：多个线程共同操作的变量
  • 同步监视器：俗称锁
    • 任何一个类的对象都可以来充当锁
    • 要求多个线程必须共用同一把锁
    • 在实现Runnable接口创建多线程的方式中，考虑使用this充当同步监视器
    • 在继承Thread类创建多线程的方式中，慎用this来充当同步监视器，考虑使用当前类来充当同步监视器

特点

  • 好处：解决线程的安全问题
  • 局限性：操作同步代码时，只能有一个线程参与，其他线程等待。相当于一个单线程的过程，效率低

代码实现

实现Runnable接口创建多线程的方式
/**
 * 创建三个窗口买票，票数100张：使用实现Runnable接口的方式实现的
 */
class WindowThread implements Runnable{

    private int ticket = 100;
    // private Object obj = new Object();

    public void run() {
        while (true) {
            //此时this：唯一的WindowThread对象
            synchronized(this){// 方式二：synchronized(obj){
                if (ticket > 0) {
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread(). getName() + ":" + "买票，票号为" + ticket);
                    ticket--;
                }else{
                    break;
                }
            }
        }
    }
}

public class Test1 {

    public static void main(String[] args) {
        WindowThread window = new WindowThread();

        Thread w1 = new Thread(window);
        Thread w2 = new Thread(window);
        Thread w3 = new Thread(window);

        w1.setName("窗口1");
        w1.start();
        w2.setName("窗口2");
        w2.start();
        w3.setName("窗口3");
        w3.start();
    }
}
继承Thread类创建多线程的方式
class Window extends Thread {
    // 大家公用数据，只有100张票
    private static int ticket = 100;
    private static Object obj = new Object();
    public void run() {
        while (true) {
            //方式二
            synchronized(Window.class){
                // 方式一：synchronized(obj){
                //synchronized(this)错误的，此时this代表着三个对象
                if(ticket > 0){
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(getName() + ":" + "买票，票号为" + ticket);
                    ticket--;
                }else{
                    break;
                }
            }

        }
    }
}

public class Test2 {
    public static void main(String[] args) {
        Window w1 = new Window();
        Window w2 = new Window();
        Window w3 = new Window();

        w1.setName("窗口1");
        w2.setName("窗口2");
        w3.setName("窗口3");

        w1.start();
        w2.start();
        w3.start();
    }
}

同步方法

如果操作共享数据的代码完整的声明在一个方法中，就可以将此方法声明同步的

格式

利用synchronized 修饰方法

public synchronized void XXX(){

}

或

public static synchronized void XXX(){

}

说明

  • synchronized修饰方法时锁定的是调用该方法的对象
  • 同步方法仍然涉及到同步监视器，只是不需要我们显示的声明
  • 非静态的同步方法，同步监视器是this
  • 静态的同步方法，同步监视器是当前类本身（Window.class）

代码实现

实现Runnable接口创建多线程的方式

非静态同步方法，调用this

class WindowThread3 implements Runnable{

    private int ticket = 100;
    private static boolean isFlag = true;
    // private Object obj = new Object();

    public void run() {
        while (isFlag) {
            show();
        }
    }

    public synchronized void show(){//同步监视器：this
        if (ticket > 0) {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread(). getName() + ":" + "买票，票号为" + ticket);
            ticket--;
        }else{
            isFlag = false;
        }
    }
}

public class Test3 {
    public static void main(String[] args) {
        WindowThread3 window = new WindowThread3();

        Thread w1 = new Thread(window);
        Thread w2 = new Thread(window);
        Thread w3 = new Thread(window);

        w1.setName("窗口1");
        w1.start();
        w2.setName("窗口2");
        w2.start();
        w3.setName("窗口3");
        w3.start();
    }
}
继承Thread类创建多线程的方式

静态同步方法，调用当前类本身

class Window4 extends Thread{
    private static int ticket = 100;
    private static boolean isFlag = true;

    @Override
    public void run() {
        while(isFlag){
            show();
        }
    }

    public static synchronized void show(){
        //同步监视器：Window.class
        if(ticket > 0){
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread(). getName() + ":" + "买票，票号为" + ticket);
            ticket--;
        }else{
            isFlag = false;
        }
    }
}

public class Test4 {
    public static void main(String[] args) {
        Window4 w1 = new Window4();
        Window4 w2 = new Window4();
        Window4 w3 = new Window4();

        w1.setName("窗口1");
        w2.setName("窗口2");
        w3.setName("窗口3");

        w1.start();
        w2.start();
        w3.start();
    }
}

通过Lock（锁）解决线程安全问题

步骤

  1. 实例化ReentrantLock

    private ReentrantLock lock = new ReentrantLock(true);

    • true代表公平
    • 不填默认为false

  2. 调用锁的方法

    lock.lock();

  3. 调用解锁的方法

    lock.unlock();

注意：其中调用lock()方法和unlock()方法时要用try()finally()包住
技术图片

代码实现

class Window5 implements Runnable {

    private int ticket = 100;

    //1.实例化ReentrantLock
    private ReentrantLock lock = new ReentrantLock(true);

    public void run() {
        while (true) {
            try{
                //2.调用锁定的方法：lock()
                lock.lock();

                if (ticket > 0) {

                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    System.out.println(Thread.currentThread().getName() +  "卖票" + ":" + "票号为" + ticket);
                    ticket--;
                }else{
                    break;
                }
            }finally{
                //3.调用解锁的方法：unlock()
                lock.unlock();
            }
        }

    }

}

public class Test5 {
    public static void main(String[] args) {
        Window5 window = new Window5();

        Thread t1 = new Thread(window);
        Thread t2 = new Thread(window);
        Thread t3 = new Thread(window);

        t1.setName("窗口1：");
        t2.setName("窗口2：");
        t3.setName("窗口3：");

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

synchronized和Lock的异同

异

  • synchronized机制在执行完相应的代码逻辑后自动释放同步监视器
  • Lock需要手动的启动同步（lock），同时结束同步也需要手动的实现（unlock）

同

  • 都可以解决线程安全问题

释放锁与不释放锁的操作

释放锁的操作

  • 当前线程的同步方法、同步代码块执行结束
  • 当前线程在同步代码块、同步方法中出现了未处理的Error或Exception，导致异常结束
  • 当前线程在同步代码块、同步方法中遇到了break、return终止了该代码块、方法的继续执行
  • 当前线程在同步代码块、同步方法中执行了线程对象的wait()方法，当前线程暂停，并释放锁

不释放锁的操作

  • 线程在执行同步代码块或同步方法时，程序调用了Thread.sleep()或Thread.yield()方法暂停当前线程的执行
  • 线程在执行同步代码块时，其他线程调用了该线程的suspend()方法将该线程挂起，该线程不会释放锁（同步监视器）
    • 尽量避免使用suspend()（挂起）和resume()（继续执行）来控制线程

使用顺序

Lock--->同步代码块--->同步方法

死锁

  • 不同线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁
  • 出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续
  • 使用同步时，避免出现死锁
  • 避免
    • 专门的算法
    • 尽量减少同步资源的定义
    • 尽量避免嵌套同步

以上是关于线程的同步的主要内容，如果未能解决你的问题，请参考以下文章

起底多线程同步锁(iOS)

多线程编程

第十次总结 线程的异步和同步

详解C++多线程

进程线程同步异步

配置 kafka 同步刷盘