多线程交替打印AB或者字符串，生产者消费者，死锁等例子

最新推荐文章于 2024-03-07 08:57:08 发布
最新推荐文章于 2024-03-07 08:57:08 发布
阅读量2.3k 收藏 8
点赞数
分类专栏： java多线程 文章标签： 多线程交替打印 简单死锁 交替打印字符串 多线程面试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Hollake/article/details/93529701
版权

 

目录

使用wait和notify实现生产者消费者

使用阻塞队列来实现生产者消费者模式 

两线程交替打印AB

简单死锁例子

这个也是交替打印AB

交替打印字符串，例如：hello world

 使用wait和notify实现生产者消费者

public class Main2 {
    public static void main(String[] args) {
        LinkedList<Integer> list = new LinkedList<>();
        int MAX = 5;//生产商品总数
        Thread t1 = new Thread(){
            public void run(){
                while ( true ) {
                    synchronized (list) {//加锁
                        while ( list.size() == MAX ) {
                            try {
                                list.wait();//如果生产商品数目大于生产商品最大值，那么释放锁
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }
                        int num = (int) (Math.random() * 100);
                        list.add(num);
                        System.out.println(Thread.currentThread().getName() + "---" + num);
                        list.notify();//唤醒消费者线程，只有当前线程释放锁后才能被唤醒
                    }
                }

            }
        };
        Thread t2 = new Thread(){
            public void run(){
                while ( true ) {
                    synchronized (list) {//加锁
                        while ( list.size() == 0 ) {//消费完队列中商品进行等待
                            try {
                                list.wait();//等待释放锁
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }
                        int num = list.pop();//队列中有商品，进行消费
                        System.out.println(Thread.currentThread().getName() + "---" + num);
                        list.notify();//唤醒生产者线程，只有当前线程释放锁后才能被唤醒
                    }
                }
            }
        };
        t1.start();
        t2.start();
    }
}

使用阻塞队列来实现生产者消费者模式 

import java.util.concurrent.BlockingDeque;
import java.util.concurrent.LinkedBlockingDeque;

/**
 * Created by Hollake on 2019\8\14 0014 15:31.
 */
public class BlockingQueueTest {
    public static void main(String[] args) {
        BlockingDeque<Integer> queue = new LinkedBlockingDeque<>(5);
        Thread t1 = new Thread(){
            public void run(){
                while ( true ) {
                    int temp = (int) (Math.random() * 100);
                    try {
                        queue.put(temp);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "----" + temp);
                }
            }
        };
        Thread t2 = new Thread(){
            public void run(){
                while ( true ) {
                    try {
                        int res = queue.take();
                        System.out.println(Thread.currentThread().getName() + "----" + res);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        t1.start();
        t2.start();
    }
}

 

两线程交替打印AB

public class Main2 {
    static boolean flag = false;
    public static void main(String[] args) {
        Object LOCK = new Object();
        Thread t1 = new Thread(){
            public void run(){
                while ( true ) {
                    synchronized (LOCK) {//加锁
                        while ( flag ) {
                            try {
                                LOCK.wait();//满足条件就释放锁
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }
                        System.out.println(Thread.currentThread().getName() + "---" + "A");
                        flag = true;
                        LOCK.notify();//唤醒另外一个线程，只有当前线程释放锁后才能被唤醒
                    }
                }

            }
        };
        Thread t2 = new Thread(){
            public void run(){
                while ( true ) {
                    synchronized (LOCK) {//加锁
                        while ( !flag ) {
                            try {
                                LOCK.wait();//等待释放锁
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }
                        System.out.println(Thread.currentThread().getName() + "---" + "B");
                        flag = false;
                        LOCK.notify();//唤醒生产者线程，只有当前线程释放锁后才能被唤醒
                    }
                }
            }
        };
        t1.start();
        t2.start();
    }
}

简单死锁例子

package arithmetic;

/**
 * Created by Hollake on 2019\7\17 0017 22:08.
 */
public class Main2 {
    static boolean flag = false;
    public static void main(String[] args) {
        Object a = new Object();
        Object b = new Object();
        Thread t1 = new Thread(){
            public void run(){
                synchronized (a) {//加锁
                    try {
                        Thread.sleep(20);//必须进行睡眠等待，不睡眠等待可以，但是一般不会发生死锁，因为程序执行太快
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (b) {//拿到a锁的情况下还想拿到b锁，这与另外一个线程情况正好相反，
                        // 持有资源，不释放资源，还需要其他线程持有的资源，死锁的条件
                        System.out.println("不会执行到这里");
                    }
                }
            }
        };
        Thread t2 = new Thread(){
            public void run(){
                synchronized (b) {//加锁
                    try {
                        Thread.sleep(20);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (a) {
                        System.out.println("不会执行到这里");
                    }
                }
            }
        };
        t1.start();
        t2.start();
    }
}

这个也是交替打印AB

package arithmetic;

import java.util.LinkedList;

/**
 * Created by Hollake on 2019\6\24 0024 20:41.
 */
public class SwapPrint {
    public static void main(String[] args) throws InterruptedException {
        LinkedList<String> list = new LinkedList<>();
        list.add("A");
        list.add("B");
        list.add("A");
        list.add("B");
        Object a = new Object();
        Object b = new Object();
        MyThread myThread1 = new MyThread(b,a,list);
        MyThread myThread2 = new MyThread(a,b,list);
        (new Thread(myThread1)).start();
        Thread.sleep(100);
        (new Thread(myThread2)).start();

    }
}

class MyThread implements Runnable {
    private LinkedList<String> list;
    private Object pre;
    private Object self;

    public MyThread( Object pre, Object self,LinkedList<String> list) {
        this.self = self;
        this.pre = pre;
        this.list = list;
    }

    @Override
    public void run() {
        while ( !list.isEmpty() ){
            synchronized (pre) {//先拿到前一个线程的锁
                synchronized (self) {//接着拿到自己的锁
                    System.out.println(Thread.currentThread() + list.poll());
                    self.notify();//唤醒另外一个线程
                }
                try {
                    pre.wait();//释放前一个线程的锁，中止当前线程
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        }
    }
}

交替打印字符串，例如：hello world

import java.util.LinkedList;

/**
 * Created by Hollake on 2019\7\17 0017 22:08.
 */
public class Main2 {
    static boolean flag = false;
    static String str = "HELLO WORLD";
    static int max = str.length();
    public static void main(String[] args) {
        Object LOCK = new Object();
        LinkedList<String> list = new LinkedList<>();

        for (int i = 0; i < max; i++) {
            list.add(String.valueOf(str.charAt(i)));
        }
        Thread t1 = new Thread(){
            public void run(){
                while ( max > 0 ) {
                    synchronized (list) {//加锁
                        while ( flag ) {
                            try {
                                list.wait();//满足条件就释放锁
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }
                        //在这里为什儿要进行list是否为null的判断呢，仔细思考一下，如果不判断，例如打印两个字母ab，
                        // 第一次线程t1打印a后，继续到try中，调用list.wait()方法，释放锁，线程t2拿到锁，继续打印b，
                        // 接着同样的释放锁，线程t1从try中的wait()方法中被唤醒，继续执行，但是list中已经没有了元素，
                        // 所以调用pop()方法直接会抛出空指针异常
                        if (list.size() > 0) {
                            System.out.println(Thread.currentThread().getName() + "---" + list.pop());
                        }
                        max--;
                        flag = true;
                        list.notify();//唤醒t2线程，只有当前线程释放锁后才能被唤醒
                    }
                }

            }
        };
        Thread t2 = new Thread(){
            public void run(){
                while ( max > 0 ) {
                    synchronized (list) {//加锁
                        while ( !flag ) {
                            try {
                                list.wait();//释放锁等待被唤醒
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }
                        if (list.size() > 0) {
                            System.out.println(Thread.currentThread().getName() + "---" + list.pop());
                        }
                        max--;
                        flag = false;
                        list.notify();//唤醒t1线程，只有当前线程释放锁后才能被唤醒
                    }
                }
            }
        };
        t1.start();
        t2.start();
    }
}

 

Hollake
关注
专栏目录
204道高频Java面试题❤️五万字❤️全路线十八个模块❤️面试10多家中大厂后的总结（建议收藏）
公号：一条coding
09-13 1万+
整理了两周
Java多线程通信:交替打印ABAB实例
09-07
主要介绍了Java多线程通信:交替打印ABAB实例，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
Java实现多线程交替打印a、b、c、......字符（多种实现方式）
weixin_45685353的博客
07-10 3295
面试经常会遇到使用Java多线程交替打印字符的问题，本文采用synchronized+wait/notify、ReentranLock+Condition、LockSupport多种方式讲解实现思路以及最终的代码实现
编程实现三个线程ABC，并让它们顺次打印ABC
wwhhff11
03-16 1002
package ABC;import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock;public class Main { private static final Lock lock=ne
java 线程交替打印AB 如何使用多线程轮流打印参数 两个线程依次打印AB 两个线程依次打印1,2
最新发布
求是
03-07 483
变量的解决方案，通常情况下，该类将被用于原子性地更新状态标识位，比如flag。类提供的方法：详情可查看源码。AtomicBoolean 是什么？AtomicBoolean提供了一种。朋友们，简简单单吃个羊头 --！可以看下源码 基于unsafe实现的。还有很多的其他方法，暂不介绍！LockSupport用来。，直至获得许可，当调用。
java多线程交替打印A和B
许诗宇的博客
02-12 3554
 关键就是打印A和B的方法，synchronized的对象是同一个，即持有的锁是同一个，都是print这个类的实例 然后又一个标志，当不是自己的时候，就释放自己的锁，并让线程进入等待状态，就是this.wait（） 当while执行完后，说明到自己的回合，打印字符，设置标志，然后唤醒锁为this的线程。 package test.t4thread; class Print{ bool...
史上最全 Java 多线程面试题及答案
澎湖Java架构师的博客
09-22 162
这是有用的，比方说StringBuffer，它是一个线程安全的类，自然最常用的append()方法是一个同步方法，我们写代码的时候会反复append字符串，这意味着要进行反复的加锁->解锁，这对性能不利，因为这意味着Java虚拟机在这条线程上要反复地在内核态和用户态之间进行切换，因此Java虚拟机会将多次append方法调用的代码进行一个锁粗化的操作，将多次的append的操作扩展到append方法的头尾，变成一个大的同步块，这样就减少了加锁–>解锁的次数，有效地提升了代码执行的效率。某条线程执行了多久？
秋春招总结之并发多线程
weixin_44015043的博客
08-04 5277
文章目录前言1. 基础进程与线程的区别区别包含关系什么是并发编程的三要素？ 在Java中如何来保证多线程的安全运行。什么是并行，什么是并发，说一说两者之间的区别：2. 实现Java的多线程创建的四种方式：继承 Thread 类；实现Runnable接口实现 Callable 接口使用线程池Thread类与Runnable接口的比较：CallableCallable 接口3. 线程的各个状态4. 各种状态下的问题关于线程同步以及线程调度的相关方法sleep和wait的区别sleep和yield 的区别star
求职与面试(一):Java必备
热门推荐
Floating Cat
02-19 4万+
今天要谈的主题是关于求职.求职是在每个技术人员的生涯中都要经历多次,对于我们大部分人而言,在进入自己心仪的公司之前少不了准备工作,有一份全面细致面试题将帮助我们减少许多麻烦.在跳槽季来临之前,特地做这个系列的文章,一方面帮助自己巩固下基础,另一方面也希望帮助想要换工作的朋友.
JVM、JUC、网络、线程
pybstudyjava的博客
03-29 723
1. JVM 面试常见： 请你谈谈你对 JVM 的理解? java 8 虚拟机和之前的变化更新? 什么是 OOM，什么是栈溢出 StackOverFlowError? 怎么分析? JVM的常用调优参数有哪些? 内存快照如何抓取，怎么分析 Dump 文件？ 谈谈JVM中，类加载器你的认识 1. JVM的位置 JRE：java 开发环境，包含了 JVM（ C++ 语言编写的） 一个个（.class）类文件 JRE–JVM 操作系统（Windows，Linux，Mac） 硬件体系（I
Java多线程通信：交替打印ABAB
木木
08-20 6650
使用wait()和notify()实现Java多线程通信：两个线程交替打印A和B，如ABABAB public class Test { public static void main(String[] args) { final PrintAB print = new PrintAB(); new Thread(new Runnable() { ...
多线程交替打印ABABAB
qq_37822034的博客
03-01 800
package testJunit; import java.util.ArrayList; import java.util.LinkedList; import java.util.List; class Solution{ public static void main(String[] args) { Thread t1 = new Thread(new Threada()...
多线程交替输出AB
qq_25775675的博客
05-30 226
多线程案例
线程的状态
雷大大的程序猿的博客
10-12 149
我百度了一下，有说三种，有说四种，有说五种，有说六种，还有说七种。下边列出六种的说法，六种见的比较多。 这是线程的六种状态 初始(NEW)：新创建了一个线程对象，但还没有调用start()方法。 运行(RUNNABLE)：Java线程中将就绪（ready）和运行中（running）两种状态笼统的称为“运行”。 线程对象创建后，其他线程(比如main线程）调用了该对象的start()方法...
两个线程交替打印AB
qq_42453201的博客
01-04 596
package github.write.funding2.mapper; /** * @Author: MaiYu * @Date: Create in 19:32 2020/12/12 */ public class Main3 { // public static void main(String[] args) { // String s=new String(); // System.out.println("3"); // } priv
使用多线程循环交替打印字符
asdfrt8686的博客
06-13 353
使用Condition +Lock进行实现 private static int count_print = 1; （1）此处只能用static，来实现每打印一个字符，下一个字符长度加一，static是使该变量只有一个副本，任何改变都是对这个副本的内容做操作（2）若是想实现每打印一组，下一组字符每个字符长度加一，就不使用static，因为三个线程，有三个线程实例即ThreadTe...
Java多线程：线程通信：生产者 和 消费者 || 顺序打印
weixin_61635597的博客
01-12 364
在Object.java中，定义了wait(), notify()和notifyAll()等方法。wait()的作用是让当前线程进入等待状态，同时，wait()也会让当前线程释放它所持有的锁。notify()和notifyAll()的作用，则是唤醒当前对象上的等待线程；notify()是唤醒单个线程，而是唤醒所有的线程。异常这 三个wait(),notify(), notifyAll()方法只有在synchronized方法或synchronized代码块中才能使用，否则会报异常如下是图示说明。
线程理解：三个线程交替顺序打印ABC
jike11231的博客
06-28 2249
一、题目描述 建立三个线程A、B、C，A线程打印10次字母A，B线程打印10次字母B,C线程打印10次字母C，但是要求三个线程同时运行，并且实现交替打印，即按照ABCABCABC的顺序打印 这里参照网上方案，特此整理如下： 1、使用synchronized， wait和notifyAll 2、使用Lock->ReentrantLock 和 state标志 3、使用Lock->ReentrantLock 和Condition（await 、signal、signalAll） 4、使用AtomicI
线程通信之交替打印ab
qq_29328611的博客
06-25 221
(交替打印ab) public class CalculatorTest { static boolean flag = true; static class Word { String s; public Word(String a) { s = a; } public void setS(String a) { s = a; } public String getS() { return s; } } static Word s = new
C#多线程实战：生产者消费者模型与线程同步
"C#多线程学习之(三)生产者和消费者用法分析" 在C#编程中，多线程技术是实现并发处理和优化应用程序性能的关键手段。本篇文章聚焦于C#中的生产者和消费者模式，这是一种常见的多线程应用场景，常用于处理数据的生产...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值