Java-线程同步

于 2022-05-14 22:36:54 发布
阅读量140 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： Java 文章标签： java 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/ispringmw/article/details/124775637
本文详细介绍了Java中实现线程安全的三种方式：同步代码块、同步方法和Lock锁，通过实例代码展示了它们的使用，并讨论了它们的优缺点和适用场景。同步能解决线程安全问题，但可能导致效率降低。Lock锁提供了更细粒度的控制，优于synchronized。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

Java-线程同步

在Java中，我们通过同步机制，来解决线程的安全问题。

实现线程安全的三种方法：

1.同步代码块

synchronized（同步监视器）{
    //需要被同步的代码
}

说明：

  1. 操作共享数据的代码，即为需要被同步的代码。 -->不能包含代码多了，也不能包含代码少了。

  2. 共享数据：多个线程共同操作的变量。比如：ticket就是共享数据。

  3. 同步监视器，俗称：锁。任何一个类的对象，都可以充当锁。要求：多个线程必须要共用同一把锁。

    补充：在实现Runnable接口创建多线程的方式中，我们可以考虑使用this充当同步监视器。
    在继承Thread类创建多线程的方式中，慎用this充当同步监视器，考虑使用当前类充当同步监视器。

    代码举例：

    继承Thread类的多线程同步代码块的实现

package com.lmw.thred1;

/**
 * @author 
 * @version 1.0.0
 * @createTime 2022/5/14 11:03
 * @description 使用同步代码块来处理继承Thread类时的线程安全问题
 */

public class WindowTest1 {
    public static void main(String[] args) {
        // 创建子线程1的对象
        MyWindow m1 = new MyWindow();
        MyWindow m2 = new MyWindow();
        MyWindow m3 = new MyWindow();
        // 设置子线程1 的名称
        m1.setName("线程1");
        // 启动子线程1
        m1.start();

        m2.setName("线程2");
        m2.start();

        m3.setName("线程3");
        m3.start();
    }
}

class MyWindow extends Thread {
    // 通过 声明静态变量的方式实现不同对象控制对一个变量
    private static int ticket = 3;

    @Override
    public void run() {

        while (true){
            // 使用synchronized 锁住同一个对象，这个对象对应调用它的对象要唯一，**多个线程必须要共用同一把锁
            synchronized (MyWindow.class){
                // 操作共享数据的代码块，被锁包住
                if(ticket > 0) {
                    System.out.println(getName() + "卖票，票号为：" + ticket);
                    ticket --;
                }else {
                    break;
                }

            }
        }
    }

}

实现Runnable接口的多线程同步代码块的实现

package com.lmw.thred1;

/**
 * @author 
 * @version 1.0.0
 * @createTime 2022/5/14 11:27
 * @description 使用同步代码块解决实现Runnable接口的线程安全问题
 */

public class Window2 {
    public static void main(String[] args) {
        MyWindow2 m2 = new MyWindow2();
        // 创建多个线程时不需要再创建多个对象
        Thread t1 = new Thread(m2);
        t1.setName("线程1");
        t1.start();

        Thread t2 = new Thread(m2);
        t2.setName("线程2");
        t2.start();

        Thread t3 = new Thread(m2);
        t3.setName("线程3");
        t3.start();

    }
}

class MyWindow2 implements Runnable {
    private int ticket = 3;

    @Override
    public void run() {

        while (true) {
            // 此时this 是唯一的 MyWindow2 对象
            synchronized (this) {
                if(ticket > 0) {
                    System.out.println(Thread.currentThread().getName() + "卖票,票号为：" + ticket);
                    ticket --;
                }else {
                    break;
                }

            }

        }

    }
}

2.同步方法

​ 如果操作共享数据的代码完整的声明在一个方法中，我们不妨将此方法声明同步的

在方法体声明时加上 synchronized ,特别地继承Thread类是需要将操作共享数据的方法声明为静态的

说明：

  1. 同步方法仍然涉及到同步监视器，只是不需要我们显式的声明。
  2. 非静态的同步方法，同步监视器是：this
  3. 静态的同步方法，同步监视器是：当前类本身 类.class

​

​ 代码举例：

继承Thread类的多线程同步方法的实现

package com.lmw.thred1;

/**
 * @author limingwei6
 * @version 1.0.0
 * @createTime 2022/5/14 14:04
 * @description 使用同步方法来处理继承Thread类时的线程安全问题
 */

public class WindowTest3 {
    public static void main(String[] args) {
        MyWindow3 m1 = new MyWindow3();
        m1.setName("线程1");
        m1.start();

        MyWindow3 m2 = new MyWindow3();
        m2.setName("线程1");
        m2.start();

        MyWindow3 m3 = new MyWindow3();
        m3.setName("线程1");
        m3.start();

    }
}

class MyWindow3 extends Thread {
    private static int ticket = 3;
    boolean flag = true;
    @Override
    public void run() {
        while (flag) {
            flag = show();
        }
    }

    private static synchronized boolean show() {// 同步监视器 MyWindow3.class
//    private synchronized boolean show() {// 同步监视器有三个： t1,t2,t3,这样不能解决线程同步问题
        if(ticket > 0) {
            System.out.println(Thread.currentThread().getName() + "卖票，票号为：" + ticket);
            ticket --;
            return true;
        }else {
            return false;
        }
    }
}

实现Runnable接口多线程方法的实现

package com.lmw.thred1;

/**
 * @author 
 * @version 1.0.0
 * @createTime 2022/5/14 14:05
 * @description 使用同步方法解决实现Runnable接口的线程安全问题
 */

public class WindowTest4 {
    public static void main(String[] args) {
        MyWindow4 m1 = new MyWindow4();

        Thread t1 = new Thread(m1);
        t1.setName("线程1");
        t1.start();

        Thread t2 = new Thread(m1);
        t2.setName("线程2");
        t2.start();

        Thread t3 = new Thread(m1);
        t3.setName("线程3");
        t3.start();

    }
}

class MyWindow4 implements Runnable {
    private int ticket = 3;
    @Override
    public void run() {

        while (true) {
            if (ticket > 0) {
                show();
            }else {
                break;
            }
        }

    }
    // 操作共享数据的方法在一个方法中, 在声明方法时加 synchronized 给这个方法加锁
    private synchronized void show() {// 同步监视器是this
        if(ticket > 0) {
            System.out.println(Thread.currentThread().getName() + "卖票，票号为：" + ticket);
            ticket --;
        }
    }

}

3.Lock锁

package com.lmw.thred1;

import java.util.concurrent.locks.ReentrantLock;

/**
 * @author
 * @version 1.0.0
 * @createTime 2022/5/14 14:41
 * @description 使用Lock接口的方式解决多线程的线程同步安全
 */

public class LockTest {
    public static void main(String[] args) {
        MyWindow5 m2 = new MyWindow5();
        // 创建多个线程时不需要再创建多个对象
        Thread t1 = new Thread(m2);
        t1.setName("线程1");
        t1.start();

        Thread t2 = new Thread(m2);
        t2.setName("线程2");
        t2.start();

        Thread t3 = new Thread(m2);
        t3.setName("线程3");
        t3.start();
    }
}


class MyWindow5 implements Runnable {
    private int ticket = 3;
    //1. 声明一个 实现Lock接口的类 ReentrantLock 的对象 ,可以接收参数，true表示平均分配
    private ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        while (true) {
            try {
                //2.调用lock.lock 加锁方法
                lock.lock();
                if(ticket > 0) {
                    System.out.println(Thread.currentThread().getName() + "卖票,票号为：" + ticket);
                    ticket --;
                }else {
                    break;
                }
            }finally {
                //3.解锁
                lock.unlock();
            }

        }
    }
}

4.线程同步的利弊：

  1. 同步的方式，解决了线程的安全问题。
  2. 操作同步代码时，只能一个线程参与，其他线程等待。相当于是一个单线程的过程，效率低。

5.三种方式对比

synchronized 与 Lock的异同？

  • 相同：二者都可以解决线程安全问题
  • 不同：synchronized机制在执行完相应的同步代码以后，自动的释放同步监视器
  •    Lock需要手动的启动同步（lock()，同时结束同步也需要手动的实现（unlock()）

使用的优先顺序：

  • Lock —> 同步代码块（已经进入了方法体，分配了相应资源 ) —> 同步方法（在方法体之外)
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值