阿里面试原题:创建 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