Java多线程：依次打印ABC

最新推荐文章于 2025-06-15 12:53:44 发布

原创最新推荐文章于 2025-06-15 12:53:44 发布 · 365 阅读

0 ·

CC 4.0 BY-SA版权

大Java小Note 专栏收录该内容

5 篇文章

订阅专栏

这篇博客探讨了如何在Java中使用synchronized和lock实现多线程环境下依次打印字母ABC的方案，详细解析了两种不同的并发控制方法。

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

文章目录

- - - 1.多线程依次打印ABC - synchronized
    - 2.多线程依次打印ABC - lock

1.多线程依次打印ABC - synchronized

package com.self.thread.moreThread;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadTest {
    static int state = 0;
    //作为synchronized锁的同一对象
    private static Object 0 = new Object();
    
    public static void main(String[] args) {
        //线程池
        ExecutorService service = Executors.newCachedThreadPool();
        service.execute(new ThreadA());
        service.execute(new ThreadB());
        service.execute(new ThreadC());
        service.shutdown();
    }
    
    //线程A
    public static class ThreadA implements Runnable {
        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                synchronized (0) {
                    while (state % 3 != 0) {
                        try {
                            o.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    System.out.println("--------第" + (i + 1) + "轮打印--------");
                    System.out.println("A");
                    state++;
                    o.notifyAll();
                }
            }
        }
    }
    
    //线程B
    public static class ThreadB implements Runnable {
        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                synchronized (o) {
                    while (state % 3 != 1) {
                        try {
                            o.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    System.out.println("B");
                    state++;
                    o.notifyAll();
                }
            }
        }
    }
    
    //线程C
    public static class ThreadC implements Runnable {
        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                synchronized (o) {
                    while (state % 3 != 2) {
                        try {
                            o.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    System.out.println("C");
                    state++;
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    o.notifyAll();
                }
            }
        }
    }
}

2.多线程依次打印ABC - lock

package com.self.thread.moreThread;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ThreadTest2 {
    static int state = 0;
    private static Lock lock = new ReentrantLock();
    
    public static void main(String[] args) {
        ExecutorService service = Executors.newCachedThreadPool();
        service.submit(new ThreadA());
        service.submit(new ThreadB());
        service.submit(new ThreadC());
        service.shutdown();
    }
    
    //线程A
    public static class ThreadA implements Runnable {
        @Override
        public void run() {
            for (int i = 0; i < 10; ) {
                lock.lock();
                if (state % 3 == 0) {
                    System.out.println("--------第" + (i + 1) + "轮打印--------");
                    System.out.println("A");
                    state++;
                    i++;
                }
                lock.unlock();
            }
        }
    }
    
    //线程B
    public static class ThreadB implements Runnable {
        @Override
        public void run() {
            for (int i = 0; i < 10; ) {
                lock.lock();
                if (state % 3 == 1) {
                    System.out.println("B");
                    state++;
                    i++;
                }
                lock.unlock();
            }
        }
    }
    
    //线程C
    public static class ThreadC implements Runnable {
        @Override
        public void run() {
            for (int i = 0; i < 10; ) {
                lock.lock();
                if (state % 3 == 2) {
                    System.out.println("C");
                    state++;
                    i++;
                }
                lock.unlock();
            }
        }
    }
}