多线程并发编程（三）：多线程同步互斥Synchronized

最新推荐文章于 2022-08-08 17:26:40 发布
最新推荐文章于 2022-08-08 17:26:40 发布
阅读量953 收藏 2
点赞数
分类专栏： 多线程并发 文章标签： 多线程 编程 并发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/saytime/article/details/51190620
版权

前言

其实就是针对线程安全问题进行的，最经典的问题就是银行转账的问题，A向B转账的同时，A也在存钱，比如A有1000元，向B转200元，A自己存300元，按道理最后是1100元，如果没有同步机制，那么就可能发生问题，如果在A转账的时候，余额还没有开始减，然后A存钱的时候，拿到的余额是没有减去的，然后A的余额开始减去，但是存钱的线程拿到的余额是没有减去的，那么最后计算赋值可能变成了1000+300=1300了，同样，有可能在存钱的时候还没有计算赋值，另外一个转账线程进来，拿到的值是还没有加起来的，也就是1000元，那么转账线程执行完，1000-200=800，按道理是1100的，所以可能出现钱多了，或者钱少了的问题。

线程安全问题

package test01;

public class TraditionalThreadSychronized {

    class Outputer{

        // 这里打印，采取一个字母一个字母的打印，打印完一个名字再换行
        public void output(String name){
            int len = name.length();
            for (int i = 0; i < len; i++) {
                System.out.print(name.charAt(i));
            }
            System.out.println();
        }
    }

    public void init(){
        // 注意这里要申明为final
        final Outputer out = new Outputer();

        // 线程1：打印zhangsan
        new Thread(new Runnable() {

            @Override
            public void run() {
                while(true){
                    try {
                        Thread.sleep(50);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    out.output("zhangsan");
                }
            }

        }).start();

        // 线程2：打印lisi
        new Thread(new Runnable() {

            @Override
            public void run() {
                while(true){
                    try {
                        Thread.sleep(50);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    out.output("lisi");
                }
            }

        }).start();
    }

    public static void main(String[] args) {
        new TraditionalThreadSychronized().init();
    }
}

如果不考虑线程安全问题的话，理想结果应该是zhangsan，lisi 循环打印，但是这里没有使用同步机制，输出结果中可以发现，出现了原本不想要的结果：
这里写图片描述
可以发现，打印出来的数据有些有问题。

解决办法： 采用同步机制，使用synchronized

使用同步解决线程安全问题

1、使用当前对象锁

class Outputer{

        // 这里打印，采取一个字母一个字母的打印，打印完一个名字再换行
        public void output(String name){

            synchronized(this){
                int len = name.length();
                for (int i = 0; i < len; i++) {
                    System.out.print(name.charAt(i));
                }
                System.out.println();
            }

        }
    }

2、使用当前对象属性的对象锁

    class Outputer{
        private String xxx = "";

        // 这里打印，采取一个字母一个字母的打印，打印完一个名字再换行
        public void output(String name){

            synchronized(xxx){
                int len = name.length();
                for (int i = 0; i < len; i++) {
                    System.out.print(name.charAt(i));
                }
                System.out.println();
            }

        }
    }

3、使用同步方法

    class Outputer{
        private String xxx = "";

        // 这里打印，采取一个字母一个字母的打印，打印完一个名字再换行
        public synchronized void output(String name){
            int len = name.length();
            for (int i = 0; i < len; i++) {
                System.out.print(name.charAt(i));
            }
            System.out.println();
        }
    }

其实，使用同步方法，就是使用的当前对象的对象锁

输出结果：

这里写图片描述

打印结果中不再出现之前的打印问题，zhangsan，lisi都完整打印出来了，当然如果要实现轮流依次打印那种，之后会给出实现方案的，这里只讨论线程安全机制。

同步之间的互斥问题

第一种情况：同步代码块与同步方法

package test01;

public class TraditionalThreadSychronized {

    class Outputer{

        // 同步代码块形式
        public void output(String name){
            synchronized(this){
                int len = name.length();
                for (int i = 0; i < len; i++) {
                    System.out.print(name.charAt(i));
                }
                System.out.println();
            }
        }

        // 同步方法形式
        public synchronized void output2(String name){
            int len = name.length();
            for (int i = 0; i < len; i++) {
                System.out.print(name.charAt(i));
            }
            System.out.println();
        }
    }

    public void init(){
        // 注意这里要申明为final
        final Outputer out = new Outputer();

        // 线程1：打印zhangsan
        new Thread(new Runnable() {

            @Override
            public void run() {
                while(true){
                    try {
                        Thread.sleep(50);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    // 调用的是同步代码块形式的方法output
                    out.output("zhangsan");
                }
            }

        }).start();

        // 线程2：打印lisi
        new Thread(new Runnable() {

            @Override
            public void run() {
                while(true){
                    try {
                        Thread.sleep(50);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    // 调用的是同步方法形式的方法output2
                    out.output2("lisi");
                }
            }

        }).start();
    }

    public static void main(String[] args) {
        new TraditionalThreadSychronized().init();
    }
}

结果：不会出现线程安全问题。

分析：第一个线程调用的是同步代码块的方法output，第二个线程调用的是同步方法形式的方法output2，那么结果会怎么样了，会出现线程安全问题吗？答案当然是不会，前面说到了，同步方法其实使用的就是当前对象的对象锁，而同步代码块中用的也是当前对象的对象锁，所以肯定是互斥的，即不能当一个线程拿到了这个对象的对象锁的时候，其他对象不能调用当前对象需要对象锁的方法，说的通俗点就是，线程1进入output方法的时候，拿到了当前对象的对象锁，线程2没有当前对象的对象锁，所以访问不了方法output2，同样线程2拿到之后，线程1也访问不了output方法。

特殊情况：当然如果同步代码块中使用的是其他对象锁，那么就会出现线程安全问题了，因为两个方法使用的不是同一个对象的对象锁。

第二种情况：同步代码块与静态同步方法

package test01;

public class TraditionalThreadSychronized {

    static class Outputer{

        // 同步代码块形式
        public void output(String name){
            synchronized(this){
                int len = name.length();
                for (int i = 0; i < len; i++) {
                    System.out.print(name.charAt(i));
                }
                System.out.println();
            }
        }

        // 同步方法形式
        public synchronized void output2(String name){
            int len = name.length();
            for (int i = 0; i < len; i++) {
                System.out.print(name.charAt(i));
            }
            System.out.println();
        }

        // 静态同步代码块
        public static synchronized void output3(String name){
            int len = name.length();
            for (int i = 0; i < len; i++) {
                System.out.print(name.charAt(i));
            }
            System.out.println();
        }

    }

    public void init(){
        // 注意这里要申明为final
        final Outputer out = new Outputer();

        // 线程1：打印zhangsan
        new Thread(new Runnable() {

            @Override
            public void run() {
                while(true){
                    try {
                        Thread.sleep(50);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    // 调用的是同步代码块形式的方法output
                    out.output("zhangsan");
                }
            }

        }).start();

        // 线程2：打印lisi
        new Thread(new Runnable() {

            @Override
            public void run() {
                while(true){
                    try {
                        Thread.sleep(50);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    // 调用的是静态同步方法形式的方法output3
                    out.output3("lisi");
                }
            }

        }).start();
    }

    public static void main(String[] args) {
        new TraditionalThreadSychronized().init();
    }
}

这里写图片描述

结果：会出现线程安全问题。
分析：同步代码块使用的是当前对象的对象锁，而静态同步方法使用的是当前静态类class的对象锁。
解决办法：同步代码块中使用当前类class的锁，如下：

    public void output(String name){
        synchronized(Outputer.class){
            int len = name.length();
            for (int i = 0; i < len; i++) {
                System.out.print(name.charAt(i));
            }
            System.out.println();
        }
    }

第三种情况：同步方法与静态同步方法

代码就省略了
结果：会出现线程安全问题
分析：同步方法使用的是当前类的对象的对象锁，而静态同步方法使用的是当前类的class对象的对象锁

saytime
关注
专栏目录
多线程（2）----线程的同步互斥
liupc的学习笔记
10-20 505
一、线程的安全问题                                                                                                                           点击此处返回总目录 二、同步代码块的方式，解决线程安全问题 三、同步方法的方式，解决线程安全问题 四、L...
Java多线程并发编程 Synchronized关键字
08-30
Java中的`synchronized`关键字是多线程编程中用于实现线程同步的重要机制，它确保了在多线程环境下对共享资源的访问具有互斥性和可见性。这些特性使得`synchronized`成为解决并发问题的关键工具。 1. **同步锁机制*...
多线程的同步与互斥（互斥锁、条件变量、读写锁、自旋锁、信号量）
热门推荐
青萍之末的博客
10-06 7万+
一、同步与互斥的概念   现代操作系统基本都是多任务操作系统，即同时有大量可调度实体在运行。在多任务操作系统中，同时运行的多个任务可能： 都需要访问/使用同一种资源； 多个任务之间有依赖关系，某个任务的运行依赖于另一个任务。 【同步】：   是指散步在不同任务之间的若干程序片断，它们的运行必须严格按照规定的某种先后次序来运行，这种先后次序依赖于要完成的特定的任务。最基本的场景就是：两个或两个以...
多线程的互斥与同步
老杨的专栏
05-22 743
在进行多线程编程时，难免还要碰到两个问题，那就线程间的互斥与同步：线程同步是指线程之间所具有的一种制约关系，一个线程的执行依赖另一个线程的消息，当它没有得到另一个线程的消息时应等待，直到消息到达时才被唤醒。     线程互斥是指对于共享的进程系统资源，在各单个线程访问时的排它性。当有若干个线程都要使用某一共享资源时，任何时刻最多只允许一个线程去使用，其它要使用该资源的线程必须等待，直到占用资源者
线程的同步互斥
上千主上-贝库塔
11-29 618
线程 同步互斥 java
线程的同步与互斥
qq_56870066的博客
08-08 2268
临界资源：能被多线程执行流共享访问的资源 临界区：线程内部，访问临界资源的代码 原子性：一件事情要么不执行，如果执行的话，一直执行完毕 互斥：任意时刻只允许一个线程进入临界区访问临界资源 同步：访问临界资源的过程，在安全的前提下，让访问临界资源具有合理性。...
Netty多线程并发编程
09-14
Netty多线程并发编程知识点总结 Netty多线程并发编程是指在Netty框架中使用多线程技术来实现高性能、高并发的网络编程。下面是关于Netty多线程并发编程的知识点总结： 一、 JAVA 内存模型与多线程编程 在Java中，...
java多线程编程之使用Synchronized关键字同步类方法
09-04
在Java多线程编程中，`synchronized`关键字是一个至关重要的工具，用于处理并发访问时可能出现的数据一致性问题，也就是防止“脏数据”问题。当多个线程试图访问和修改同一块共享资源时，如果不加控制，可能会导致...
java多线程并发编程 核心技术应用实践
最新发布
06-21
在《java多线程并发编程核心技术应用实践》中，我们将深入探讨Java平台上的并发机制、线程安全与同步控制、线程池以及实战技巧。 首先，我们需要理解Java中的线程基础。线程是程序执行的最小单位，一个进程可以有多...
Java多线程并发编程 并发三大要素
08-30
Java多线程并发编程并发三大要素 Java多线程并发编程中，存在三个至关重要的要素：原子性、可见性和有序性。这三个要素是Java多线程并发编程的基础，是确保多线程程序的正确性和可靠性的关键。 一、原子性 原子性...
C++多线程及互斥和同步编程详细讲解和事例
01-08
今天我给大家讲一讲C++中的多线程编程技术，C++本身并没有提供任何多线程机制，但是在windows下，我们可以调用SDK win32 api来编写多线程的程序，下面我就此简单的讲一下
多线程程序框架-利用互斥对象实现线程同步
shengzhe8688的专栏
07-01 672
多线程程序框架-利用互斥对象实现线程同步
利用互斥对象实现线程同步
u012611032的专栏
09-28 427
进程
线程同步互斥的4种方式
ZJQ的博客
02-21 1006
1.  临界区（Critical Section）：适合一个进程内的多线程访问公共区域或代码段时使用 2.  互斥量 (Mutex)：适合不同进程内多线程访问公共区域或代码段时使用，与临界区相似。 3.  事件（Event）：通过线程间触发事件实现同步互斥 4.  信号量（Semaphore）：与临界区和互斥量不同，可以实现多个线程同时访问公共区域数据，原理与操作系统中PV操作类似，先设置一...
多线程实例入门--利用互斥对象实现线程同步
so__sunshine的博客
11-24 373
c++利用windows的API来实现多线程的功能 #include #include using namespace std; DWORD WINAPI Fun(LPVOID lpParamter) { while(1) { cout<<"Fun display!\n"; Sleep(1000);} } int main
windows多线程系列002 利用互斥对象实现线程同步
余莫星辰的博客
04-11 970
接着上一篇文章我们继续讨论多线程的问题，这一次我们利用互斥对象（mutex）来解决火车站售票同步问题。 1 利用互斥对象实现线程同步 互斥对象（mutex）属于内核对象，它能够确保线程拥有对单个资源的互斥访问权。互斥对象包含一个使用数量，一个线程ID 和一个计数器。在这一节我们会用到三个函数， （1）创建互斥对象CreateMutex函数的原型声明 HANDLE WINAPI Creat
Java多线程并发编程详解：synchronized与wait/notify机制
深入探究Java多线程并发编程的要点主要聚焦于如何在Java中有效地管理线程之间的交互和同步。首先，我们关注的是关键字`synchronized`的使用，它是Java中实现线程同步的关键机制。`synchronized`可以用于修饰函数或...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值