【面试常考】多线程打印问题多种解法及总结

阿里面试原题：创建 n 个线程，依次命名为 T1、T2、T3、、、Tn，请按需打印这些线程的名字 printNum 次。

通常我们创建多线程的方式有三种，这里我给出第一种解法（synchronized）的三种形式，后面统一使用 Runnable 接口。

一、Synchronized

1、继承 Thread 类创建多线程

package com.fengluo;

import java.util.Scanner;

public class Test {

    private static int n;
    private static int printNum;
    private volatile static int cnt;

    private static class Task extends Thread {
        
        public Task(String name) {
            this.setName(name);
        }

        @Override
        public void run() {
            while (cnt < n * printNum) {
                if (cnt % n == Integer.parseInt(this.getName().substring(1)) - 1) {
                    // 代码块锁
                    synchronized (Test.class) {
                        cnt++;
                        System.out.print(this.getName());
                    }
                }
            }
        }
    }

    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        n = scan.nextInt();
        printNum = scan.nextInt();

        for (int i = 1; i <= n; i++) {
            new Task("T" + i).start();
        }
    }
}

2、实现 Runnable 接口创建多线程

package com.fengluo;

import java.util.Scanner;

public class Test {

    private static int n;
    private static int printNum;
    private volatile static int cnt = 0;

    private static class RunnableTask implements Runnable {
        @Override
        public void run() {
            while (cnt < n * printNum) {
                if (cnt % n == Integer.parseInt(Thread.currentThread().getName().substring(1)) - 1) {
                    synchronized (RunnableTask.class) {
                        cnt++;
                        System.out.print(Thread.currentThread().getName());
                    }
                }
            }
        }
    }

    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        n = input.nextInt();
        printNum = input.nextInt();

        RunnableTask runnableTask = new RunnableTask();
        for (int i = 1; i <= n; i++) {
            new Thread(runnableTask, "T" + i).start();
        }
    }
}

3、实现 Callable 接口创建多线程

package com.fengluo;

import java.util.Scanner;
import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

public class Test {

    private static int n;
    private static int printNum;
    private volatile static int cnt = 0;

    private static class Task implements Callable<Integer> {
        @Override
        public Integer call() {
            while (cnt < n * printNum) {
                if (cnt % n == Integer.parseInt(Thread.currentThread().getName().substring(1)) - 1) {
                    // 代码块锁
                    synchronized (Test.class) {
                        cnt++;
                        System.out.print(Thread.currentThread().getName());
                    }
                }
            }
            return 1;
        }
    }

    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        n = scan.nextInt();
        printNum = scan.nextInt();
        Task task = new Task();
        FutureTask<Integer> futureTask;
        for (int i = 1; i <= n; i++) {
            // 使用 FutureTask 包装 Callable 对象
            futureTask = new FutureTask<Integer>(task);
            new Thread(futureTask, "T" + i).start();
        }
    }
}

二、Lock

package com.fengluo;

import java.util.Scanner;
import java.util.concurrent.locks.ReentrantLock;

public class Test {

    private static int n;
    private static int printNum;
    private volatile static int cnt = 0;
    
    private static class RunnableTask implements Runnable {
        private final ReentrantLock lock = new ReentrantLock();
        @Override
        public void run() {
            while (cnt < n * printNum) {
                if (cnt % n == Integer.parseInt(Thread.currentThread().getName().substring(1)) - 1) {
                    lock.lock();
                    try {
                        cnt++;
                        System.out.print(Thread.currentThread().getName());
                    } finally {
                        lock.unlock();
                    }
                }
            }
        }
    }

    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        n = scan.nextInt();
        printNum = scan.nextInt();

        RunnableTask runnableTask = new RunnableTask();
        for (int i = 1; i <= n; i++) {
            new Thread(runnableTask, "T" + i).start();
        }
    }
}

在线程数固定且数量较小的情况下，可以使用 信号量 Semaphore 等同步器解决。

一般为了解决数据一致性的问题，有三种角度的方案进行选择

• 排队（最常见的有锁机制，阻塞队列，管道，屏障等）
• 投票（Paxos 算法、Raft 算法等分布式的方案）
• 隔离（ThreadLocal 线程本地的局部变量存储方式）

其中，Java 的锁根据不同角度又分为十五种锁，包括 乐观锁/悲观锁、独占锁/共享锁、互斥锁/读写锁、公平锁/非公平锁、可重入锁/不可重入锁、分段锁、自旋锁、Synchronized 锁升级的三种锁（偏向锁、轻量级锁、重量级锁）。

为了保证线程安全以及通信问题，我们一般考虑：

• Synchronized + wait + notify+ notifyAll：简单粗暴，性能较差，可重入，不可中断，不公平

• Lock + Condition + await + signal + signalAll：灵活，可重入，可中断，可公平/不公平

• volatile：轻量的同步机制，保证可见性，禁止指令重排序，不保证原子性

• 原子类：乐观锁，底层实现是 CAS 算法，是由硬件直接支持来保证原子性的，有三个操作数：内存位置V、旧的预期值A和新值B，当且仅当V符合预期值A时，CAS用新值B原子化地更新V的值，否则，它什么都不做

• 基于 AQS 同步器工具类：CountDownLatch、Semaphore、CyclicBarrier 等

• 阻塞队列 BlockingQueue