三个线程轮流打印ABC

最新推荐文章于 2024-03-23 16:33:06 发布
最新推荐文章于 2024-03-23 16:33:06 发布
阅读量1k 收藏 1
点赞数 1
分类专栏： Java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_40996976/article/details/123694869
版权
本文详细介绍了Java中线程的两种创建方式：继承Thread类和实现Runnable接口，并通过实例展示了死锁的产生及解决方法。接着，通过三个示例分别展示了三个线程轮流打印ABC、两个线程交替打印奇偶数以及N个线程依次打印1到100的并发控制策略，深入理解Java并发编程的关键技术。

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

文章目录

线程的创建

package JUC.juc1;

public class CreateThread {
    public static void main(String[] args) {
        ThreadDemo1 threadDemo1 = new ThreadDemo1();
        threadDemo1.setName("Thread Method");
        threadDemo1.start();

        Thread runnable = new Thread(new ThreadDemo2(), "Runnable interface");
        runnable.start();
        // 直接调用run方法的话，是主线程（main）执行run方法
        runnable.run();

        new Thread(
                () -> 
                System.out.println(Thread.currentThread() + "run3()方法执行"), "run3")
                .start();
    }
}

// 1. 继承Thread方法
class ThreadDemo1 extends Thread {

    @Override
    public void run() {
        System.out.println(Thread.currentThread() + "run1()方法执行");
    }
}

// 2. 实现Runnable接口
class ThreadDemo2 implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread() + "run2()方法执行");
    }
}

死锁

package JUC.juc1;

/**
 * 死锁
 *
 * 解决方法：资源需要按照顺序来获取，两个线程都需要先获取资源1，再获取资源2.
 */
public class DeadLockDemo {

    private static Object resource1 = new Object();
    private static Object resource2 = new Object();

    public static void main(String[] args) {

        new Thread(() -> {
            synchronized (resource1){
                System.out.println(Thread.currentThread() + "get resource1");
                try {
                    // 等待1秒，让两个线程各自拿到资源。
                    Thread.sleep(1000);
                } catch (InterruptedException e){
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread() + "waiting get resource2");

                synchronized (resource2){
                    System.out.println(Thread.currentThread() + "get resource2");
                }
            }
        }, "线程1").start();

        Thread thread = new Thread(new Thread2(), "线程2");
        thread.start();

    }

    static class Thread2 implements Runnable{

        @Override
        public void run() {

            // 同步代码块
            synchronized (resource2) {
                System.out.println(Thread.currentThread() + "get resource2");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e){
                    e.printStackTrace();
                }

                System.out.println(Thread.currentThread() + "waiting get resource1");
                synchronized (resource1) {
                    System.out.println(Thread.currentThread() + "get resource1");
                }
            }

        }
    }
}

三个线程轮流打印ABC

package JUC.juc1;

public class PrintABC {

    // 条件变量
    private int num;
    // 锁
    private static final Object Lock = new Object();

    public static void main(String[] args) {

        PrintABC printABC = new PrintABC();
        // 轮流打印50次
        for (int i =0; i < 50; i++){
            // 线程1
            Thread thread1 = new Thread(new Runnable() {
                @Override
                public void run() {
                    printABC.printMehthod("A", 0);
                }
            });
            thread1.setName("A");
            thread1.start();
            // 线程2
            new Thread(new Runnable() {
                @Override
                public void run() {
                    printABC.printMehthod("B", 1);
                }
            }, "B").start();
            // 线程3
            new Thread(() -> printABC.printMehthod("C", 2), "C").start();
        }
        Lock.notifyAll();
    }
	
    /**
    name: ABC
    targetNum:0,1,2
    */
    private void printMehthod(String name, int targetNum){
        synchronized (Lock)
        {
            while (num % 3 != targetNum) {
                try {
                    Lock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            num++;
            System.out.println(name);
            Lock.notifyAll();
        }
    }
}

// A
// B
// C
// A
// B
// C

两个线程轮流打印奇偶数

package JUC.juc1;

public class PrintOddEven {
    // 条件变量
    private volatile int count;
    // 锁
    private Object monitor = new Object();

    PrintOddEven(int initCount){
        this.count = initCount;
    }

    public static void main(String[] args) {
        PrintOddEven printOddEven = new PrintOddEven(0);
        new Thread(() -> printOddEven.printMethod(), "odd ").start();
        new Thread(() -> printOddEven.printMethod(), "even").start();
    }

    private void printMethod() {
        synchronized (monitor)
        {
            while (count < 100) {
                try {
                    System.out.print(Thread.currentThread().getName() + ":");
                    System.out.println(++count);
                    monitor.notifyAll();
                    monitor.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            // 防止 while 退出循环后，还有线程被阻塞为唤醒，导致主线程无法退出
            monitor.notifyAll();
        }
    }
}

// odd :1
// even:2
// odd :3
// even:4
// odd :5
// even:6
// odd :7
// even:8

N个线程轮流连续打印1到100.

package JUC.juc1;

/**
 * N个线程轮流打印1到100
 */
public class PrintOneByOneTo100 {

    private volatile int num = 0;
    private static int N = 4;
    private int maxnum = 100;
    private Object monitor = new Object();

    public static void main(String[] args) {
        PrintOneByOneTo100 printOneByOneTo100 = new PrintOneByOneTo100();
        for (int i = 0; i < N; i++){
            int finalI = i;
            new Thread(() -> printOneByOneTo100.printMethod(finalI), "Thread" + i).start();
        }
    }
    private void printMethod(int targetNum) {
        while (true) {
            synchronized (monitor) {
                while (num % N != targetNum) {
                    if (num >=  maxnum){
                        break;
                    }
                    try {
                        monitor.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                if (num >= maxnum) {
                    break;
                }
                num++;
                System.out.println(Thread.currentThread() + ":" + num);
                monitor.notifyAll();
            }
        }
    }
}

// Thread[Thread0,5,main]:1
// Thread[Thread1,5,main]:2
// Thread[Thread2,5,main]:3
// Thread[Thread3,5,main]:4
// Thread[Thread0,5,main]:5
// Thread[Thread1,5,main]:6
// Thread[Thread2,5,main]:7
// Thread[Thread3,5,main]:8
// Thread[Thread0,5,main]:9
三个线程循环打印abc
u014694510的博客
08-31 866
方法一：使用一个条件变量进行同步 使用C++11的标准方法一：线程语法，用一个全局变量state控制条件变量的wait()阻塞等待时机，用notify_all()唤醒条件变量。 具体的代码如下，3个线程分别打印ABC，循环10次： #include <iostream> #include <thread> #include <mutex> #includ...
多线程交替打印ABC的多种实现方法
热门推荐
想作会飞的鱼的博客
08-17 6万+
一、题目描述建立三个线程A、B、C，A线程打印10次字母A，B线程打印10次字母B,C线程打印10次字母C，但是要求三个线程同时运行，并且实现交替打印，即按照ABCABCABC的顺序打印。二、Synchronized同步法1、基本思路使用同步块和wait、notify的方法控制三个线程的执行次序。具体方法如下：从大的方向上来讲，该问题为三线程间的同步唤醒操作，主要的目的就是ThreadA->Thre
三个线程顺序打印ABC?我有十二种做法，彻底掌握多线程同步通信机制
三分恶的博客
09-30 2959
三个线程顺序打印ABC?一次搞懂十二种做法，彻底理解线程同步通信机制！
三个线程循环打印ABC
weixin_42989986的博客
03-29 231
三个线程循环打印ABC 利用ReentrantLock锁，获取线程状态。 import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; public class PrintAbc { ...
c++ 三个线程轮流打印ABC
agentky的博客
08-27 1164
#include<iostream> #include<thread> using namespace std; #include<condition_variable> condition_variable cv; mutex m; int flag = 0; void fun_a() { unique_lock<mutex> lk(m); cout << "fun_a" << endl; int count = 0; wh
Java 三个线程轮流打印ABC (二) 使用Semaphore解决打印abc
求是
02-22 448
Semaphore 中有个计数器，表示可用的许可证数量。调用acquire()方法，可以获取许可证，使用完后调用release()方法，释放许可证。比如以数据库连接池为例，现有30个线程请求数据库连接，但连接池的最大连接数为10，故会有20个线程请求失败。为控制连接数，可用Semaphore操作。可用于控制并发数量，即同时访问特定资源的线程数量，通过协调各个线程，保证合理使用公共资源。1. 如何用java解决：启动三个线程，依次打印“A”， “B”， “C”？
Java 三个线程轮流打印ABC 使用wait notify解决打印abc
求是
02-22 349
1. 如何用java解决：启动三个线程，依次打印“A”， “B”， “C”？3. 有很多方法都可以解决。如信号量，LockSupport, join等。
实现三个线程轮流执行顺序打印ABC
Bobo‘s Home
06-16 1万+
这道题目在多线程的面试题中可能遇到的比较多，由于最近一直在学习Java多线程编程的知识，这里做一个总结，总结的可能并不是很全面，有问题或者有更好的编程方法也欢迎大家指出。 这道题目的实现方式很多，这里就以我了解的进行一个总结。 首先，我们看一下题目： 有三个线程A、B、C，采用多线程的方式使三个线程轮流执行顺序打印ABC 10次，结果如下： 通过wait/notify实现 package tes...
三个线程顺序打印ABC?我有十二种做法！
Java技术攻略的博客
03-20 830
这篇文章给大家带来了三个线程顺序打印ABC的的十二种做法，里面有些写法肯定是冗余的，大家有没有什么更好的写法呢？通过十二种题解，我们基本上把Java并发中主要的线程同步和通信方式过了一遍，相信通过这道题的实践，我们也能对Java线程的同步和通信有更深的理解。两个线程，一个线程打印奇数，一个线程打印偶数按照顺序，三个线程分别打印A5次，B10次，C15次。
用三个线程按顺序循环打印abc三个字母，比如abcabcabc（四种方式实现
最新发布
m0_60707660的博客
03-23 1323
虽然面试套路众多，但对于技术面试来说，主要还是考察一个人的技术能力和沟通能力。不同类型的面试官根据自身的理解问的问题也不尽相同，没有规律可循。上面提到的关于这些JAVA基础、三大框架、项目经验、并发编程、JVM及调优、网络、设计模式、spring+mybatis源码解读、Mysql调优、分布式监控、消息队列、分布式存储等等面试题笔记及资料。
编程实现三个线程ABC，并让它们顺次打印ABC
wwhhff11
03-16 1030
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
三个线程顺序打印ABC
WHEgqing的专栏
08-31 286
#include <iostream> #include <thread> #include <condition_variable> #include <mutex> #include <atomic> using namespace std; atomic<int> control_int; mutex s_mutex_; condition_variable s_convar; void PrintID(int id) {
三个线程轮流执行顺序打印ABC
fzq13994952987的博客
11-07 347
输出为：AAAAAAA...BBBBBBB...CCCCCCC... class XXX{ static int num = 1; public void print() { for(int i=0;i<10;i++) { if(num==1) System.out.println("A"); else if(num==2) System.out.pr...
每日一问 - 三个线程交替打印 ABCABC
面朝大海，春暖花开
09-24 279
每日一问 - 三个线程交替打印 ABCABC… 问题 三个线程交替打印 ABCABC.. ? 三个线程交替打印 ABCABC.. 10 次? 解决方案 三个线程交替打印 ABCABC… 创建共享资源 ： /** * wait notify 实现 ABC交替打印 */ public class ABCCoreHolder { private int counter = 0; public void printA() throws InterruptedException {
三个线程交替顺序打印ABC
xucong996的博客
08-20 244
使用ReentrantLock和Condition实现 public static class ABC_Runnable implements Runnable{ //需要打印的字符 private final char word; //lock对象 private final Lock lock; //当前任务condition private final Condition currentCondition; //当前任务执行完.
面试题：用三个线程按顺序循环打印 abc 三个字母，比如 abcabcabc
wjw的博客
03-12 4953
揣摩出题人意图，应该希望你用wait notify notifyAll来一环套一环进行线程通信，从而按顺序循环打印abc，也就是说，打印了a就打印b然后打印c。 思路就是我们三个线程用同一把锁，刚开始，a线程获取锁，打印a，设置下一个打印b，并同时唤醒bc，这时候，bc线程都阻塞等待，如果c抢到了锁，进入代码执行，由于不符合条件，会wait（同时释放锁），直到b抢到锁，符合条件打印，如此，顺序执...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值