DeepSeek Java 多线程打印的12种实现方法

稚辉君.MCA_P8_Java2025-12-01 8:57

Java 多线程打印的12种实现方法

下面我将为你详细介绍12种不同的Java多线程打印实现方法：

  1. synchronized + wait/notify 方法
java 复制代码 
public class Method1_Synchronized {
    private static final Object lock = new Object();
    private static int number = 1;
    private static final int MAX = 10;
    
    public static void main(String[] args) {
        new Thread(() -> {
            synchronized (lock) {
                while (number <= MAX) {
                    if (number % 2 == 1) {
                        System.out.println(Thread.currentThread().getName() + ": " + number++);
                        lock.notify();
                    } else {
                        try {
                            lock.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
                lock.notify();
            }
        }, "Thread-A").start();
        
        new Thread(() -> {
            synchronized (lock) {
                while (number <= MAX) {
                    if (number % 2 == 0) {
                        System.out.println(Thread.currentThread().getName() + ": " + number++);
                        lock.notify();
                    } else {
                        try {
                            lock.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }, "Thread-B").start();
    }
}
  1. ReentrantLock + Condition 方法
java 复制代码 
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class Method2_ReentrantLock {
    private static final ReentrantLock lock = new ReentrantLock();
    private static final Condition condition = lock.newCondition();
    private static int number = 1;
    private static final int MAX = 10;
    
    public static void main(String[] args) {
        new Thread(() -> {
            while (number <= MAX) {
                lock.lock();
                try {
                    if (number % 2 == 1) {
                        System.out.println(Thread.currentThread().getName() + ": " + number++);
                        condition.signal();
                    } else {
                        condition.await();
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                }
            }
        }, "Thread-A").start();
        
        new Thread(() -> {
            while (number <= MAX) {
                lock.lock();
                try {
                    if (number % 2 == 0) {
                        System.out.println(Thread.currentThread().getName() + ": " + number++);
                        condition.signal();
                    } else {
                        condition.await();
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                }
            }
        }, "Thread-B").start();
    }
}
  1. Semaphore 信号量方法
java 复制代码 
import java.util.concurrent.Semaphore;

public class Method3_Semaphore {
    private static Semaphore semaphoreA = new Semaphore(1);
    private static Semaphore semaphoreB = new Semaphore(0);
    private static int number = 1;
    private static final int MAX = 10;
    
    public static void main(String[] args) {
        new Thread(() -> {
            while (number <= MAX) {
                try {
                    semaphoreA.acquire();
                    if (number <= MAX) {
                        System.out.println(Thread.currentThread().getName() + ": " + number++);
                    }
                    semaphoreB.release();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "Thread-A").start();
        
        new Thread(() -> {
            while (number <= MAX) {
                try {
                    semaphoreB.acquire();
                    if (number <= MAX) {
                        System.out.println(Thread.currentThread().getName() + ": " + number++);
                    }
                    semaphoreA.release();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "Thread-B").start();
    }
}
  1. LockSupport 方法
java 复制代码 
import java.util.concurrent.locks.LockSupport;

public class Method4_LockSupport {
    private static int number = 1;
    private static final int MAX = 10;
    private static Thread threadA, threadB;
    
    public static void main(String[] args) {
        threadA = new Thread(() -> {
            while (number <= MAX) {
                if (number % 2 == 1) {
                    System.out.println(Thread.currentThread().getName() + ": " + number++);
                    LockSupport.unpark(threadB);
                } else {
                    LockSupport.park();
                }
            }
        }, "Thread-A");
        
        threadB = new Thread(() -> {
            while (number <= MAX) {
                if (number % 2 == 0) {
                    System.out.println(Thread.currentThread().getName() + ": " + number++);
                    LockSupport.unpark(threadA);
                } else {
                    LockSupport.park();
                }
            }
        }, "Thread-B");
        
        threadA.start();
        threadB.start();
    }
}
  1. CyclicBarrier 方法
java 复制代码 
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

public class Method5_CyclicBarrier {
    private static final int THREAD_COUNT = 2;
    private static CyclicBarrier barrier = new CyclicBarrier(THREAD_COUNT);
    private static int number = 1;
    private static final int MAX = 10;
    
    public static void main(String[] args) {
        new Thread(() -> {
            while (number <= MAX) {
                try {
                    if (number % 2 == 1) {
                        System.out.println(Thread.currentThread().getName() + ": " + number++);
                    }
                    barrier.await();
                } catch (InterruptedException | BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }
        }, "Thread-A").start();
        
        new Thread(() -> {
            while (number <= MAX) {
                try {
                    if (number % 2 == 0) {
                        System.out.println(Thread.currentThread().getName() + ": " + number++);
                    }
                    barrier.await();
                } catch (InterruptedException | BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }
        }, "Thread-B").start();
    }
}
  1. CountDownLatch 方法
java 复制代码 
import java.util.concurrent.CountDownLatch;

public class Method6_CountDownLatch {
    private static int number = 1;
    private static final int MAX = 10;
    
    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < MAX; i++) {
            CountDownLatch latch = new CountDownLatch(1);
            CountDownLatch nextLatch = new CountDownLatch(1);
            
            new Thread(() -> {
                try {
                    latch.await();
                    if (number <= MAX) {
                        System.out.println(Thread.currentThread().getName() + ": " + number++);
                    }
                    nextLatch.countDown();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }, "Thread-" + (i + 1)).start();
            
            latch.countDown();
            nextLatch.await();
        }
    }
}
  1. BlockingQueue 方法
java 复制代码 
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

public class Method7_BlockingQueue {
    private static BlockingQueue<Integer> queueA = new ArrayBlockingQueue<>(1);
    private static BlockingQueue<Integer> queueB = new ArrayBlockingQueue<>(1);
    private static int number = 1;
    private static final int MAX = 10;
    
    static {
        try {
            queueA.put(0); // 初始化信号
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    
    public static void main(String[] args) {
        new Thread(() -> {
            while (number <= MAX) {
                try {
                    queueA.take();
                    if (number <= MAX) {
                        System.out.println(Thread.currentThread().getName() + ": " + number++);
                    }
                    queueB.put(0);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "Thread-A").start();
        
        new Thread(() -> {
            while (number <= MAX) {
                try {
                    queueB.take();
                    if (number <= MAX) {
                        System.out.println(Thread.currentThread().getName() + ": " + number++);
                    }
                    queueA.put(0);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "Thread-B").start();
    }
}
  1. Phaser 方法
java 复制代码 
import java.util.concurrent.Phaser;

public class Method8_Phaser {
    private static int number = 1;
    private static final int MAX = 10;
    
    public static void main(String[] args) {
        Phaser phaser = new Phaser(2);
        
        new Thread(() -> {
            while (number <= MAX) {
                if (number % 2 == 1) {
                    System.out.println(Thread.currentThread().getName() + ": " + number++);
                }
                phaser.arriveAndAwaitAdvance();
            }
        }, "Thread-A").start();
        
        new Thread(() -> {
            while (number <= MAX) {
                if (number % 2 == 0) {
                    System.out.println(Thread.currentThread().getName() + ": " + number++);
                }
                phaser.arriveAndAwaitAdvance();
            }
        }, "Thread-B").start();
    }
}
  1. Exchanger 方法
java 复制代码 
import java.util.concurrent.Exchanger;

public class Method9_Exchanger {
    private static int number = 1;
    private static final int MAX = 10;
    
    public static void main(String[] args) {
        Exchanger<Boolean> exchanger = new Exchanger<>();
        
        new Thread(() -> {
            boolean flag = true;
            while (number <= MAX) {
                try {
                    if (number % 2 == 1) {
                        System.out.println(Thread.currentThread().getName() + ": " + number++);
                    }
                    flag = exchanger.exchange(flag);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "Thread-A").start();
        
        new Thread(() -> {
            boolean flag = false;
            while (number <= MAX) {
                try {
                    if (number % 2 == 0) {
                        System.out.println(Thread.currentThread().getName() + ": " + number++);
                    }
                    flag = exchanger.exchange(flag);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "Thread-B").start();
    }
}
  1. CompletableFuture 方法
java 复制代码 
import java.util.concurrent.CompletableFuture;

public class Method10_CompletableFuture {
    private static int number = 1;
    private static final int MAX = 10;
    
    public static void main(String[] args) {
        CompletableFuture<Void> future = CompletableFuture.completedFuture(null);
        
        for (int i = 1; i <= MAX; i++) {
            final int current = i;
            future = future.thenRunAsync(() -> {
                System.out.println(Thread.currentThread().getName() + ": " + current);
            });
        }
        
        future.join();
    }
}
  1. 线程池 + Future 方法
java 复制代码 
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class Method11_ThreadPool {
    private static final int MAX = 10;
    
    public static void main(String[] args) throws Exception {
        ExecutorService executor = Executors.newFixedThreadPool(2);
        
        Future<?> future1 = executor.submit(() -> {
            for (int i = 1; i <= MAX; i += 2) {
                System.out.println(Thread.currentThread().getName() + ": " + i);
            }
        });
        
        Future<?> future2 = executor.submit(() -> {
            for (int i = 2; i <= MAX; i += 2) {
                System.out.println(Thread.currentThread().getName() + ": " + i);
            }
        });
        
        future1.get();
        future2.get();
        executor.shutdown();
    }
}
  1. AtomicInteger + 自旋锁方法
java 复制代码 
import java.util.concurrent.atomic.AtomicInteger;

public class Method12_AtomicInteger {
    private static AtomicInteger number = new AtomicInteger(1);
    private static final int MAX = 10;
    private static volatile int turn = 1; // 1: Thread-A, 2: Thread-B
    
    public static void main(String[] args) {
        new Thread(() -> {
            while (number.get() <= MAX) {
                if (turn == 1 && number.get() <= MAX) {
                    System.out.println(Thread.currentThread().getName() + ": " + number.getAndIncrement());
                    turn = 2;
                }
            }
        }, "Thread-A").start();
        
        new Thread(() -> {
            while (number.get() <= MAX) {
                if (turn == 2 && number.get() <= MAX) {
                    System.out.println(Thread.currentThread().getName() + ": " + number.getAndIncrement());
                    turn = 1;
                }
            }
        }, "Thread-B").start();
    }
}

方法特点对比

方法 优点 缺点 适用场景

synchronized 简单易用，JVM内置 性能相对较低 简单的同步需求

ReentrantLock 功能丰富，性能好 需要手动释放锁 复杂的同步需求

Semaphore 灵活的许可控制 可能产生死锁 资源池、限流

LockSupport 精确控制线程 需要管理park/unpark 需要精细控制线程

CyclicBarrier 可重复使用 需要固定线程数 多阶段任务

CountDownLatch 一次性同步 不可重复使用 主线程等待子线程

BlockingQueue 解耦生产消费 需要管理队列 生产者消费者模式

Phaser 灵活的阶段控制 相对复杂 多阶段复杂任务

Exchanger 线程间数据交换 只能两个线程 配对线程数据交换

CompletableFuture 函数式编程 链式调用复杂 异步编程

线程池 资源管理 需要关闭线程池 任务执行管理

AtomicInteger 无锁操作 自旋消耗CPU 简单的原子操作

这些方法涵盖了Java并发编程的主要工具类，你可以根据具体需求选择合适的方法。

相关推荐
z***75151 小时前
Linux系统离线部署MySQL详细教程（带每步骤图文教程）
linux·mysql·adb
JienDa1 小时前
JienDa聊PHP：电商系统实战架构深度解析与优化策略
开发语言·架构·php
弘毅 失败的 mian1 小时前
Linux 基本工具详解
linux·运维·服务器·经验分享·笔记
弘毅 失败的 mian1 小时前
Linux 编程第一个小程序：进度条
linux·经验分享·笔记·小程序·apache
代码不停1 小时前
Java栈题目练习
java·开发语言
wadesir1 小时前
提升系统效率的关键（Linux文件系统性能优化入门教程）
linux·网络·性能优化
864记忆1 小时前
在IDEA中如何使用翻译插件？
java·ide·intellij-idea
w***48821 小时前
Springboot 3项目整合Knife4j接口文档（接口分组详细教程）
java·spring boot·后端
n***63271 小时前
华为HuaweiCloudStack（一）介绍与架构
服务器·华为·架构
热门推荐
01GitHub 镜像站点02BongoCat - 跨平台键盘猫动画工具03UV安装并设置国内源04安娜的档案(Anna’s Archive) 镜像网站/国内最新可访问入口（持续更新）05【保姆级教程】免费使用Gemini3的5种方法！免翻墙/国内直连06Linux下V2Ray安装配置指南0746个Nano-banana 精选提示词，持续更新中08“我的电脑”图标没了怎么办 4种方法找回09全球最强模型Grok4，国内已可免费使用！（附教程）10KGG转MP3工具|非KGM文件|解密音频