线程的同步机制

最新推荐文章于 2024-03-11 16:32:38 发布
最新推荐文章于 2024-03-11 16:32:38 发布
阅读量179 收藏
点赞数
分类专栏： 笔记 java 文章标签： java 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/HT412515/article/details/109880714
版权
java 同时被 2 个专栏收录
53 篇文章 2 订阅
订阅专栏
笔记
47 篇文章 1 订阅
订阅专栏

文章目录

b站学习视频以及笔记-尚硅谷_Java零基础教程

java入门必备-适合初学者的全套完整版教程(宋红康主讲)

线程的同步机制

1. 背景

例子：创建个窗口卖票，总票数为100张.使用实现Runnable接口的方式

  • 问题：卖票过程中，出现了重票、错票 -->出现了线程的安全问题
  • 问题出现的原因：当某个线程操作车票的过程中，尚未操作完成时，其他线程参与进来，也操作车票。
  • 如何解决：当一个线程a在操作ticket的时候，其他线程不能参与进来。直到线程a操作完ticket时，其他线程才可以开始操作ticket。这种情况即使线程a出现了阻塞，也不能被改变。
class  Windows extends Thread{

    private static int ticket = 100;

    @Override
    public void run() {
        while (true){
            if (ticket>0){
                System.out.println(getName()+"：票号："+ticket);
                ticket--;
            }else{
                break;
            }
        }

    }

    public Windows(String name){
        super(name);
    }
}

public class WindowsTest {

    public static void main(String[] args) {

        Windows w1 = new Windows("窗口一");
        Windows w2 = new Windows("窗口二");
        Windows w3 = new Windows("窗口三");
        w1.start();
        w2.start();
        w3.start();
    }
}

结果（出现重票现象）：

image-20201120221105496

2. Java解决方案：同步机制

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

方式一：同步代码块

synchronized(同步监视器){

//需要被同步的代码
}

class Window1 implements Runnable{

    private int ticket = 100;
//    Object obj = new Object();
//    Dog dog = new Dog();
    @Override
    public void run() {
//        Object obj = new Object();
        while(true){
            synchronized (this){//此时的this:唯一的Window1的对象   //方式二：synchronized (dog) {

                if (ticket > 0) {

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

                    System.out.println(Thread.currentThread().getName() + ":卖票，票号为：" + ticket);


                    ticket--;
                } else {
                    break;
                }
            }
        }
    }
}


public class WindowTest1 {
    public static void main(String[] args) {
        Window1 w = new Window1();

        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();
    }

}


class Dog{

}

说明：

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

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

3.同步监视器，俗称：锁。任何一个类的对象，都可以充当锁。

要求：多个线程必须要共用同一把锁。

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

方式二：同步方法

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

关于同步方法的总结：

同步方法仍然涉及到同步监视器，只是不需要我们显式的声明。

非静态的同步方法，同步监视器是：this

静态的同步方法，同步监视器是：当前类本身

class Window3 implements Runnable {

    private int ticket = 100;

    @Override
    public void run() {
        while (true) {

            show();
        }
    }

    private synchronized void show(){//同步监视器：this
        //synchronized (this){

            if (ticket > 0) {

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

                System.out.println(Thread.currentThread().getName() + ":卖票，票号为：" + ticket);

                ticket--;
            }
        //}
    }
}


public class WindowTest3 {
    public static void main(String[] args) {
        Window3 w = new Window3();

        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();
    }

}

方式三：Lock锁 — JDK 5.0新增

从JDK 5.0开始，Java提供了更强大的线程同步机制——通过显式定义同 步锁对象来实现同步。

同步锁使用Lock对象充当。

java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的 工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象 加锁，线程开始访问共享资源之前应先获得Lock对象。

ReentrantLock 类实现了 Lock ，它拥有与 synchronized 相同的并发性和 内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以 显式加锁、释放锁。

image-20201120223544232

class Window implements Runnable{

    private int ticket = 100;
    //1.实例化ReentrantLock
    private ReentrantLock lock = new ReentrantLock();

    @Override
    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 LockTest {
    public static void main(String[] args) {
        Window w = new Window();

        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. 死锁：

image-20201120223725454

public static void main(String[] args) {

    StringBuffer s1 = new StringBuffer();
    StringBuffer s2 = new StringBuffer();


    new Thread(){
        @Override
        public void run() {

            synchronized (s1){

                s1.append("a");
                s2.append("1");

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


                synchronized (s2){
                    s1.append("b");
                    s2.append("2");

                    System.out.println(s1);
                    System.out.println(s2);
                }


            }

        }
    }.start();


    new Thread(new Runnable() {
        @Override
        public void run() {
            synchronized (s2){

                s1.append("c");
                s2.append("3");

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

                synchronized (s1){
                    s1.append("d");
                    s2.append("4");

                    System.out.println(s1);
                    System.out.println(s2);
                }


            }



        }
    }).start();


}

结果：

什么也没输出，但是程序一直不会自动结束，因为出现了死锁现象

使用同步机制将单例模式中的懒汉式改写为线程安全的。

class Bank{

    private Bank(){}

    private static Bank instance = null;

    public static Bank getInstance(){
        //方式一：效率稍差
//        synchronized (Bank.class) {
//            if(instance == null){
//
//                instance = new Bank();
//            }
//            return instance;
//        }
        //方式二：效率更高
        if(instance == null){

            synchronized (Bank.class) {
                if(instance == null){

                    instance = new Bank();
                }

            }
        }
        return instance;
    }

}

面试题：写一个线程安全的单例模式。
饿汉式。
懒汉式：上面提供的。

4. 练习

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

分析：
1.是否是多线程问题？ 是，两个储户线程
2.是否有共享数据？ 有，账户（或账户余额）
3.是否有线程安全问题？有
4.需要考虑如何解决线程安全问题？同步机制：有三种方式。

class Account{
    private double balance;

    public Account(double balance) {
        this.balance = balance;
    }

    //存钱
    public synchronized void deposit(double amt){
        if(amt > 0){
            balance += amt;

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

            System.out.println(Thread.currentThread().getName() + ":存钱成功。余额为：" + balance);
        }
    }
}

class Customer extends  Thread{

    private Account acct;

    public Customer(Account acct) {
        this.acct = acct;
    }

    @Override
    public void run() {

        for (int i = 0; i < 3; i++) {
            acct.deposit(1000);
        }

    }
}


public class AccountTest {

    public static void main(String[] args) {
        Account acct = new Account(0);
        Customer c1 = new Customer(acct);
        Customer c2 = new Customer(acct);

        c1.setName("甲");
        c2.setName("乙");

        c1.start();
        c2.start();
    }
}

5. 面试题：synchronized 与 Lock的异同？

image-20201120224245001

相同： 二者都可以解决线程安全问题

不同： synchronized机制在执行完相应的同步代码以后，自动的释放同步监视器

Lock需要手动的启动同步（lock()，同时结束同步也需要手动的实现（unlock()）

使用的优先顺序：

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

6. 利弊

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

小涛今天没敲代码
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java线程同步机制_动力节点Java学院整理
08-30
Java线程同步机制是Java多线程编程中的关键概念，主要用来解决多个线程并发访问共享资源时可能出现的安全问题。当多个线程试图同时修改同一数据时，如果没有适当的同步措施，就可能导致数据不一致或者出现意外的结果...
线程同步机制
欢迎一起学习交流
04-10 3822
目录 一、线程同步机制 ​ 二、同步方法 ​ 三、同步块 一、线程同步机制 处理多线程问题时，多个线程访问同一个对象，并且某些线程还想修改这个对象。这时需要线程同步，线程同步是一种等待机制，多个县农村需要同时访问此对象的线程进入这个对象的等待池形成队列，等待前面线程使用完毕，下一个线程再使用 解决方法：队列和锁 保证线程同步的安全性 由于同一进程的多个线程共享一块存储空间，在带来方便的同时，也带来了访问冲突问题，为了保证数据在方法中被访问时的正确性，在访问时加锁
什么是线程同步？常用的线程同步机制有哪些？
luoluoal的博客
07-14 2241
线程同步是指在多个线程并发执行时，保证它们按照一定的顺序执行以达到正确的结果。常用的线程同步机制有以下几种：互斥锁：使用互斥锁（Mutex）可以保证在同一时间只有一个线程可以访问共享资源。当一个线程获得了互斥锁后，其他线程需要等待该线程释放锁才能继续访问共享资源。信号量：信号量（Semaphore）是一种计数器，用来控制同时访问某个共享资源的线程数量。当计数器大于0时，线程可以访问资源并将计数器减1；当计数器等于0时，线程需要等待其他线程释放资源后才能继续访问。
线程同步的四种方式及原理
向诸位大佬虚心学习
03-11 1624
线程的同步是为了保证多个线程按照特定的顺序、协调地访问共享资源，避免数据不一致和竞争条件等问题。本文说明了四种实现线程同步的方式。
java的线程同步机制synchronized关键字的理解_.docx
10-09
Java 线程同步机制中 synchronized 关键字的理解 Java 的线程同步机制是为了解决多个线程共享同一片存储空间所带来的访问冲突问题。其中，synchronized 关键字是 Java 语言中解决这种冲突的重要机制。 ...
Java多线程同步机制研究分析.pdf
12-27
Java多线程同步机制研究分析 Java多线程同步机制是Java编程语言中的一种机制，它允许多个线程同时执行，提高了系统资源的利用率和安全性。但是，多线程中最重要的问题是线程的同步和共享资源的访问保护。本文通过对...
linux线程同步
06-13
介绍了linux线程同步的所有方式，包括互斥、自旋、信号量、条件变量等技术
线程中的同步机制问题（三种解决方法）
咸鱼老潘的编码生活
09-24 1164
线程的同步机制（三种解决方法），synchronized中的同步代码块、同步方法以及lock锁机制。
C#中四种进程或线程同步互斥的控制方法
知足者常乐
02-01 1091
此文章转载自 http://bbs.caoyuan.net/viewtopic.php?p=28660很想整理一下自己对进程线程同步互斥的理解。正巧周六一个刚刚回到学校的同学请客吃饭。在吃饭的过程中，有两个同学，为了一个问题争论的面红耳赤。一个认为.Net下的进程线程控制模型更加合理。一个认为Java下的线程池策略比.Net的好。大家的话题一下转到了进程线程同步互斥的控制问题上。回到家，想了想
使用事件机制同步线程的例子
timeshark的专栏
08-22 2016
设置三个线程，一个主线程，一个读线程和一个写线程,读线程必须在写线程写之后才能读，主线程必须在读线程读之后才能结束 实现：定义两个事件, evRead, evFinish;读线程等待evRead, 主线程等待evFinish. //使用事件机制同步线程的例子 //设置三个线程，一个主线程，一个读线程和一个写线程, //读线程必须在写线程写之后才能读，主线程必须在读线程读之后才能结束 /* 实现
多线程同步机制的几种方法
热门推荐
skyandcode的专栏
03-20 2万+
Critical Section Critical section（临界区）用来实现“排他性占有”。适用范围是单一进程 的各线程之间。它是：  一个局部性对象，不是一个核心对象。  快速而有效率。  不能够同时有一个以上的 critical section 被等待。  无法侦测是否已被某个线程放弃。 可以实现线程间互斥，不能用来实现同步。 Semaphore Sema
多线程——同步机制synchronized、lock
dgh112233的博客
04-01 1069
1、方法内的局部变量是线程安全的 假设方法中有一个局部变量，多个线程同时访问这个方法，同时使用这个局部变量，仍然是线程安全的。 为什么是这样呢？ jvm在运行时，内存中分区：程序计数器、本地方法栈、虚拟机栈、堆、方法区。 虚拟机栈：线程私有的，生命周期和线程一样，线程里的方法就对应于栈中的一个栈帧。出栈入栈的动态过程就和一般程序的一样（如果不了解栈帧，可能无法理解）。 需要知道虚拟机栈的...
多线程并发同步问题及解决方案
hqh1357054948的博客
07-20 2762
线程并发同步 线程同步其核心就在一个同步，即协同、配合，也就是按照预定顺序先后的运行，也就是你做我等，你做完并返回，然后我开始运行。 线程同步就是当线程发出一个功能调用时，在没得到结果前不会返回，且其他线程不能调用该方法。 在多线程里面有些敏感数据不允许被多个线程同时访问，使用线程同步就是要保证在一个时间内只有一个线程访问一个数据，以此来保证数据的正确性。 线程同步中可能存在的安全隐患解决方法 1...
c++ 线程同步机制
forever917的博客
03-01 1762
c++线程同步
多线程同步（安全机制）——Java多线程（2）
小高同学
05-30 1211
线程安全： 如果有多个线程同时运行一段代码，并且运行结果与单线程运行结果是一样的，那么就说是线程安全的。 1.1 线程不安全案例 通过下面这个买票的案例我们会发现会出现两种情况 一张票卖了多次的情况 出现负票的情况 public class Client3 { public static void main(String[] args) { Ticket t = new Ticket(); //同时开启三个售票窗口 Thread thread =
java 多线程 同步机制
最新发布
06-03
为了避免这种情况，Java提供了同步机制，即synchronized关键字和Lock接口。 synchronized关键字可以修饰方法或代码块，保证在同一时刻只有一个线程可以访问被修饰的方法或代码块。例如： ``` public synchronized ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值