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并发编程的主要工具类，你可以根据具体需求选择合适的方法。

相关推荐
JavaGuide3 分钟前
GitHub 4.5 万+ Star！GitNexus 把代码仓库变成了 Claude Code / Codex 能查询的知识图谱
后端·ai编程
Lam Tang13 分钟前
APS 系列文章 08
java·代理模式
独孤九剑打醒他14 分钟前
RGB‑TOT 全架构系统仿真：红外波长簇光通信完整验证
架构
子兮曰16 分钟前
DeepSeek Harness 架构深潜：一个把 Agent 运行时做成纯插件树的开源 Harness
前端·后端·deepseek
mifengxing1 小时前
文件逻辑结构、物理结构与磁盘空闲存储空间管理
大数据·linux·运维·操作系统·计算机408
萧瑟余晖1 小时前
Java深入解析篇三十三之消息队列
java·开发语言
码匠许师傅1 小时前
【C++ 面试真题】聊聊 C++ 的序列容器
java·c++·面试
这个DBA有点耶1 小时前
从库延迟的“二次放大”效应：一次大事务，拖垮整个读写分离
数据库·mysql·架构
IT爱学堂1 小时前
尚硅谷Java+AI大模型应用开发革新版本 2025年3月
java·开发语言·人工智能
子兮曰1 小时前
AI Agent 完整入门指南：从 LLM 到生产落地的 30+ 个核心概念
前端·后端·agent
热门推荐
01国内可直接用、免费额度/永久免费的大模型API清单（含 SiliconFlow、火山、阿里、智谱、百度、Kimi、DeepSeek、DMXAPI 等）02GitHub 镜像站点032026 国产 AI 大模型横评：DeepSeek、通义千问、Kimi、文心一言、星火、豆包谁更能打？04微信历史版本含下载地址（ Windows PC | 安卓 | MAC ）及设置微信不更新05Agnes AI 免费 API 接入指南：文本、生图、生视频，一套接口全免费06历年考研数学一、数学二、数学三真题试卷及答案PDF07VSCode+CodeX扩展，无法启动08AI 编程 IDE 全景解析 2026：Agent 全面接管开发链路092026年7月AI圈大地震：GPT-5.6被政府限制、Claude入驻Slack、Anthropic自研芯片10如何新建文件夹？ 电脑新建文件夹的4种方法