线程（十三）线程互斥技术synchronized

最新推荐文章于 2023-02-19 07:15:13 发布
最新推荐文章于 2023-02-19 07:15:13 发布
阅读量148 收藏
点赞数
分类专栏： 5. 并发多线程总结
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014252478/article/details/83587477
版权

创建两个线程，观察并发时出现的错误：

package 测试;
​
public class TestThread {
    public static void main(String[] args) {
        Init();
    }

    public static void Init() {


        //创建第一个线程
        new Thread(new Runnable() {

            @Override
            public void run() {
                while (true) {
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    // TODO Auto-generated method stub
                    System.out.println("yanghao");          
                }           

            }
        }).start();


        //创建第二个线程
        new Thread(new Runnable() {

            @Override
            public void run() {
                while (true) {
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    // TODO Auto-generated method stub
                    System.out.println("dingyan");
                }

            }
        }).start();

    }
​
}
​

由上测试运行：

 

可以看出：直接打印字符串看不出，并发时的错误，因此来按照字符打印
 

代码如下：

package 测试;
​
public class TestThread {
    public static void main(String[] args) {
        Init();
    }

    public static void Init() {


        //创建第一个线程
        new Thread(new Runnable() {

            @Override
            public void run() {
                while (true) {
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    // TODO Auto-generated method stub
                    //System.out.println("yanghao");
                    Outer("yanghao");
                }           

            }
        }).start();


        //创建第二个线程
        new Thread(new Runnable() {

            @Override
            public void run() {
                while (true) {
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    // TODO Auto-generated method stub
                    //System.out.println("dingyan");
                    Outer("dingyan");
                }

            }
        }).start();

    }

    public static void Outer(String str){
        int length = str.length();
        for (int i=0; i<length; i++){
            System.out.print(str.charAt(i));
        }


    }

}
​

测试得：

此时，问题就出现了：同时运行两个线程时，导致输出异常，杂乱

为了解决此问题，需要用到synchronized关键字，我们来试试：

ackage 测试;
​
public class TestThread {
    public static void main(String[] args) {
        Init();
    }

    public static void Init() {


        //创建第一个线程
        new Thread(new Runnable() {

            @Override
            public void run() {
                while (true) {
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    // TODO Auto-generated method stub
                    //System.out.println("yanghao");
                    Outer1("yanghao");
                }           

            }
        }).start();


        //创建第二个线程
        new Thread(new Runnable() {

            @Override
            public void run() {
                while (true) {
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    // TODO Auto-generated method stub
                    //System.out.println("dingyan");
                    Outer2("dingyan");
                }

            }
        }).start();

    }

    public static synchronized void Outer1(String str){
        int length = str.length();
        for (int i=0; i<length; i++){
            System.out.print(str.charAt(i));
        }   
    }

    public static synchronized void Outer2(String str){
        int length = str.length();
        for (int i=0; i<length; i++){
            System.out.print(str.charAt(i));
        }   
    }

}

此时，测试会发现恢复正常：

 

在日常工作中使用最多的、最安全的，最理想的线程延时，还是利用线程池技术ScheduledExecutorService

实现方式类似，如下：

package 测试;
​
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
​
public class TestThread {
    public static void main(String[] args) {
        Init();
    }

    public static void Init() {

        ScheduledExecutorService pool = Executors.newScheduledThreadPool(2);
        //创建第一个线程
        pool.scheduleAtFixedRate(new Runnable() {

            @Override
            public void run() {
                    Outer1("yanghao");
                }           

            }, 0, 2, TimeUnit.SECONDS);


        //创建第二个线程
        pool.scheduleAtFixedRate(new Runnable() {

            @Override
            public void run() {
                    Outer2("yanghao");
                }           

            }, 0, 2, TimeUnit.SECONDS);

    }

    public static synchronized void Outer1(String str){
        int length = str.length();
        for (int i=0; i<length; i++){
            System.out.print(str.charAt(i));
        }   
    }

    public static synchronized void Outer2(String str){
        int length = str.length();
        for (int i=0; i<length; i++){
            System.out.print(str.charAt(i));
        }   
    }

}
​

测试结果：

 

synchronized关键字用完了，那么同步锁是什么呢？

看代码：

package 测试;
​
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
​
public class TestThread {
    public static void main(String[] args) {
        Init();
    }

    public static void Init() {

        ScheduledExecutorService pool = Executors.newScheduledThreadPool(2);
        //创建第一个线程
        pool.scheduleAtFixedRate(new Runnable() {

            @Override
            public void run() {
                    Outer1("yanghao");
                }           

            }, 0, 2, TimeUnit.SECONDS);


        //创建第二个线程
        pool.scheduleAtFixedRate(new Runnable() {   
            @Override
            public void run() {
                    Outer1("dingyan");
                }           

            }, 0, 2, TimeUnit.SECONDS);

    }


    private static String token = "";

    public static synchronized void Outer1(String str){
        synchronized (token) {  //定义一个锁
            int length = str.length();
            for (int i=0; i<length; i++){
                System.out.print(str.charAt(i));
            }
            System.out.println("");
        }
    }

    public static synchronized void Outer2(String str){
        synchronized (token) {  //定义一个锁
            int length = str.length();
            for (int i=0; i<length; i++){
                System.out.print(str.charAt(i));
            }
            System.out.println("");
        }
    }

}

 

测试知道，同样实现了同步：

 

同步锁，就是在执行的地方创建同步块，将需要执行的代码放入其中，来保证代码独立运行，不受干扰。

那么token 是啥呢？

就是一把锁，简单理解：

同步代码块的锁是任意对象。只要不同的线程都执行同一个同步代码块的时候，这个锁随便设。

小师兄.
关注
专栏目录
java 多线程synchronized互斥锁demo
12-16
标题中的"java 多线程synchronized互斥锁demo"指的是一个示例，展示了如何在多线程环境下使用`synchronized`关键字创建互斥锁，确保同一时间只有一个线程可以访问特定的代码块或方法。 描述中的"一个多线程访问的同...
深入讲解java线程与synchronized关键字
08-31
- **互斥性**：synchronized保证了同一时间只有一个线程可以执行同步代码，实现线程安全。 - **可见性**：当一个线程修改了同步代码块中的变量，其他线程在退出同步块后能立即看到这个修改。 - **可重入性**：一...
关于synchronized同步方法
maimai的博客
05-04 398
修饰同步方法：作用于当前实例加锁，进入同步代码前要获得当前实例的锁。 public class TestThread { public synchronized void car1(){ System.out.println(Thread.currentThread()+"获得资源"); try { Thread.currentThread().sleep(3000); } catch (InterruptedExcepti
第三方请求头
qq_43559002的博客
04-29 181
创建SpUtils package jiaoyibo.bawei.com.retrofitdenglu.net; import android.content.Context; import android.content.SharedPreferences; public class SpUtils { private static final String FILE_NAME = ...
DDMLIB的源码解析
Gaga246的博客
12-16 398
adb是Android调试桥，可以执行各种设备操作。客户端：用来发送命令，运行在PC守护程序（adbd）：用于在手机或者模拟器上执行命令服务器：用于管理客户端和adbd之间的通信在ddmlib中使用nio与服务器进行通信，这里介绍一下nio。nio是非阻塞式IO，这里的非阻塞式是指发起IO请求时，如果没有没有数据准备好，会直接返回，而不会阻塞线程。而传统IO即BIO会阻塞线程，直到有数据准备好才执行。具体可以看Java NIO浅析AndroidDebugBridge：代表adb的客户端。
这一次，彻底搞懂Java中的synchronized关键字
smily的博客
06-14 1680
多线程并发是Java语言中非常重要的一块内容，同时，也是Java基础的一个难点。说它重要是因为多线程是日常开发中频繁用到的知识，说它难是因为多线程并发涉及到的知识点非常之多，想要完全掌握Java的并发相关知识并非易事。也正因此，Java并发成了Java面试中最高频的知识点之一。本系列文章将从Java内存模型、volatile关键字、synchronized关键字、ReetrantLock、Atomic并发类以及线程池等方面来系统的认识Java的并发知识。通过本系列文章的学习你将深入理解volatile关键字
【多线程与高并发】- synchronized锁的认知
最新发布
qq_43843951的博客
02-19 23万+
synchronized 是 Java 语言的一个关键字，它允许多个线程同时访问共享的资源，以避免多线程编程中的竞争条件和死锁问题。
【java并发】传统线程互斥技术—synchronized
武哥聊编程
05-28 6592
在多个线程同时操作相同资源的时候，就会遇到并发的问题，如银行转账啊、售票系统啊等。为了避免这些问题的出现，我们可以使用synchronized关键字来解决，下面针对synchronized常见的用法做一个总结。首先写一个存在并发问题的程序，如下：public class TraditionalThreadSynchronized { public static void main(String
Java 中线程同步机制synchronized，互斥锁，死锁，释放锁的详解
路宇的博客
05-01 1710
一、线程同步机制synchronized的理解 二、synchronized的具体使用 下面可以通过同步机制，解决多线程卖票，出现的超卖问题，代码如下 public class SellTicket { public static void main(String[] args) { // SellTicket01 sellTicket01 = new SellTicket01(); // SellTicket01 sellTicket02 = new SellTick
详解线程同步和线程互斥，Java如何实现线程同步和互斥
做兴趣使然的Hero
06-09 1101
最开始我们的操作系统的作业的调度单位是进程，但是由于每个进程都单独占据一个资源，而且进程的形态转换非常的耗费系统资源。为了系统的调度更加轻量级，能够更好的支持并发，因此引入了线程这个概念。...
java多线程互斥锁_浅谈Java多线程互斥锁
weixin_42525800的博客
02-16 879
为了解决竞争条件带来的问题，我们可以对资源上锁。多个线程共同读写的资源称为共享资源，也叫临界资源。涉及操作临界资源的代码区域称为临界区(Critical Section)。同一时刻，只能有一个线程进入临界区。我们把这种情况称为互斥，即不允许多个线程同时对共享资源进行操作，在同一时间只能被一个线程所占有的锁称之为Java多线程互斥锁。互斥锁在java中的实现就是 ReetranLock , 在访问一...
Java 多线程synchronized关键字详解(六)
09-03
Java中的`synchronized`关键字是多线程编程中的一个重要概念，用于控制并发访问共享资源，以避免数据不一致和竞态条件。在这个问题中，我们将深入理解`synchronized`的关键字用法，包括同步方法和同步块。 1. **...
浅谈Java多线程实现及同步互斥通讯
08-30
本文主要从三个方面了解和掌握多线程：多线程的实现方式、多线程的同步与互斥、多线程的通讯。通过继承Thread类和通过实现Runnable接口可以实现多线程的运行，而synchronized关键字可以用来实现线程的同步和互斥。...
Java线程之线程同步synchronized和volatile详解
08-28
synchronized是Java中的一种同步机制，用于保证一段代码在多线程执行时是互斥的。synchronized有两种用法：使用synchronized将需要互斥的代码包含起来，并上一把锁；使用synchronized修饰一个方法，使得该方法是线程...
线程（三）线程互斥技术synchronized
咖啡的博客
09-18 163
创建两个线程，观察并发时出现的错误： package 测试; public class TestThread { public static void main(String[] args) { Init(); } public static void Init() { //创建第一个线程 new Thread(n...
线程（十）关于Callable和future的介绍：
咖啡的博客
10-31 514
1、Callable类似于Runnable，为线程设计。区别在于，callable有返回值future，而Runnable则不会有返回值，同时Runnable不会抛出异常。future用于记录线程是否完成，不能用于判断线程执行是否正确。 关于callable实例： public class CallableAndFuture { public static void main(St...
线程（五）ThreadLocal解决线程范围内数据的共享及疑问？
咖啡的博客
10-29 272
1、该方法缺点是只能放入一个数据 package 多线程; import java.util.Random; //ThreadLocal来完成线程范围内数据的共享 public class pthread { private static ThreadLocal&lt;Integer&gt; threadLocal = new ThreadLocal&lt;Integer&gt;()...
Java多线程深度解析：ReentrantLock互斥锁实战
"Java多线程ReentrantLock互斥锁详解" 在Java多线程编程中，ReentrantLock（可重入锁）是JDK提供的一个高级锁机制，它弥补了synchronized关键字的一些不足，提供了更丰富的锁操作。ReentrantLock在Java并发包`java....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值