Java多线程面试题大全

下面是一个使用读写锁的示例代码：
import java.util.concurrent.locks.ReentrantReadWriteLock;
 public class ReadWriteLockDemo {
    private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    private final String[] data = new String[10];
     public void readData(int index) {
        lock.readLock().lock();
        try {
            System.out.println(Thread.currentThread().getName() + " read data: " + data[index]);
        } finally {
            lock.readLock().unlock();
        }
    }
     public void writeData(int index, String value) {
        lock.writeLock().lock();
        try {
            data[index] = value;
            System.out.println(Thread.currentThread().getName() + " write data: " + data[index]);
        } finally {
            lock.writeLock().unlock();
        }
    }
}
在上面的代码中，readData()方法使用读锁进行保护，writeData()方法使用写锁进行保护。多个线程可以同时调用readData()方法，但只有一个线程可以调用writeData()方法。

下面是一个使用悲观锁的示例代码：
public class PessimisticLockDemo {
    private final Object lock = new Object();
    private int count;
    public void increment() {
        synchronized (lock) {
            count++;
        }
    }
}

在上面的代码中，increment()方法使用synchronized关键字对count进行加锁，保证在修改count的时候其他线程不能访问count。
 下面是一个使用乐观锁的示例代码：
import java.util.concurrent.atomic.AtomicInteger;
public class OptimisticLockDemo {
    private final AtomicInteger count = new AtomicInteger();
    public void increment() {
        int oldValue, newValue;
        do {
            oldValue = count.get();
            newValue = oldValue + 1;
        } while (!count.compareAndSet(oldValue, newValue));
    }
}
在上面的代码中，increment()方法使用AtomicInteger类进行实现，使用CAS操作对count进行修改。如果在修改count的时候，count的值被其他线程修改，CAS操作就会失败，需要重新读取count的值并重试操作。

下面是一个使用线程中断的示例代码：
public class InterruptDemo extends Thread {
    @Override
    public void run() {
        while (!Thread.currentThread().isInterrupted()) {
            System.out.println("Thread is running...");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                System.out.println("Thread is interrupted.");
                Thread.currentThread().interrupt();
            }
        }
        System.out.println("Thread is stopped.");
    }
     public static void main(String[] args) throws InterruptedException {
        InterruptDemo thread = new InterruptDemo();
        thread.start();
        Thread.sleep(5000);
        thread.interrupt();
    }
}
在上面的代码中，InterruptDemo类继承了Thread类，并重写了run()方法。在run()方法中，线程会不断地输出一条信息，并检查中断状态。如果中断状态为true，则终止执行。在catch块中，线程会重新设置中断状态，以便后续的执行可以检查中断状态。
 在main()方法中，首先创建一个InterruptDemo线程并启动它。然后线程会休眠5秒钟，并在5秒钟后调用线程的interrupt()方法中断线程。当线程被中断后，会输出一条信息并停止执行。

下面是一个使用线程组的示例代码：
public class ThreadGroupDemo {
    public static void main(String[] args) {
        ThreadGroup group = new ThreadGroup("myThreadGroup");
        Thread thread1 = new Thread(group, "thread1") {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + " is running...");
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + " is stopped.");
            }
        };
        Thread thread2 = new Thread(group, "thread2") {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + " is running...");
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + " is stopped.");
            }
        };
        thread1.start();
        thread2.start();
        System.out.println("Active threads count in group " + group.getName() + ": " + group.activeCount());
        group.interrupt();
    }
}
在上面的代码中，首先创建一个名为“myThreadGroup”的线程组。然后创建两个线程，并将它们加入到线程组中。在main()方法中，首先启动这两个线程，并输出线程组中当前活动线程的数量。然后调用线程组的interrupt()方法中断线程组中的所有线程。当线程被中断后，会输出一条信息并停止执行。

下面是一个使用信号量的示例代码：
import java.util.concurrent.Semaphore;
 public class SemaphoreDemo {
    public static void main(String[] args) {
        Semaphore semaphore = new Semaphore(2); // 创建一个初始值为2的信号量
        Thread thread1 = new Thread(() -> {
            try {
                semaphore.acquire(); // 获取一个信号量
                System.out.println(Thread.currentThread().getName() + " is running...");
                Thread.sleep(5000);
                System.out.println(Thread.currentThread().getName() + " is finished.");
                semaphore.release(); // 释放一个信号量
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        Thread thread2 = new Thread(() -> {
            try {
                semaphore.acquire(); // 获取一个信号量
                System.out.println(Thread.currentThread().getName() + " is running...");
                Thread.sleep(5000);
                System.out.println(Thread.currentThread().getName() + " is finished.");
                semaphore.release(); // 释放一个信号量
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        Thread thread3 = new Thread(() -> {
            try {
                semaphore.acquire(); // 获取一个信号量
                System.out.println(Thread.currentThread().getName() + " is running...");
                Thread.sleep(5000);
                System.out.println(Thread.currentThread().getName() + " is finished.");
                semaphore.release(); // 释放一个信号量
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        thread1.start();
        thread2.start();
        thread3.start();
    }
}
在上面的代码中，首先创建一个初始值为2的信号量。然后创建三个线程，每个线程都会获取一个信号量并执行一段代码，然后释放这个信号量。由于初始值为2，所以只有两个线程可以同时执行，第三个线程必须等待其中一个线程释放了信号量后才能执行。运行上面的代码，可以看到输出结果如下：
Thread-0 is running...
Thread-1 is running...
Thread-0 is finished.
Thread-1 is finished.
Thread-2 is running...
Thread-2 is finished.
可以看到，前两个线程可以同时执行，第三个线程必须等待其中一个线程释放了信号量后才能执行。

下面是一个使用倒计时门闩的示例代码：
import java.util.concurrent.CountDownLatch;
 public class CountDownLatchDemo {
    public static void main(String[] args) throws InterruptedException {
        int n = 5; // 假设有5个任务需要完成
        CountDownLatch latch = new CountDownLatch(n); // 创建一个倒计时门闩，初始计数器值为n
         for (int i = 0; i < n; i++) {
            Thread thread = new Thread(() -> {
                // 执行任务
                System.out.println(Thread.currentThread().getName() + " is running...");
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + " is finished.");
                latch.countDown(); // 计数器减1
            });
            thread.start();
        }
         latch.await(); // 等待所有任务完成，计数器值变为0
         System.out.println("All tasks are finished.");
    }
}
在上面的代码中，首先创建一个计数器值为5的倒计时门闩。然后创建5个线程，每个线程都会执行一段代码，最后将计数器减1。主线程调用latch.await()方法等待所有线程执行完成，当计数器值变为0时，主线程继续执行。
 运行上面的代码，可以看到输出结果如下：
Thread-0 is running...
Thread-1 is running...
Thread-2 is running...
Thread-3 is running...
Thread-4 is running...
Thread-0 is finished.
Thread-2 is finished.
Thread-4 is finished.
Thread-1 is finished.
Thread-3 is finished.
All tasks are finished.
可以看到，所有线程都执行完成后，主线程才会继续执行。

下面是一个使用循环屏障的示例代码：
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
 public class CyclicBarrierDemo {
    public static void main(String[] args) {
        int n = 3; // 假设有3个线程需要同步等待
        CyclicBarrier barrier = new CyclicBarrier(n, () -> {
            // 所有线程到达屏障点后执行的代码
            System.out.println("All threads have reached the barrier.");
        });
         for (int i = 0; i < n; i++) {
            Thread thread = new Thread(() -> {
                // 执行任务
                System.out.println(Thread.currentThread().getName() + " is running...");
                try {
                    Thread.sleep(3000);
                    barrier.await(); // 等待所有线程到达屏障点
                } catch (InterruptedException | BrokenBarrierException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + " is finished.");
            });
            thread.start();
        }
    }
}
在上面的代码中，首先创建一个循环屏障，屏障点的数量为3。然后创建3个线程，每个线程都会执行一段代码，最后调用barrier.await()方法等待所有线程到达屏障点。当所有线程都到达屏障点后，会执行屏障点后面的代码。
 运行上面的代码，可以看到输出结果如下：
Thread-0 is running...
Thread-1 is running...
Thread-2 is running...
All threads have reached the barrier.
Thread-1 is finished.
Thread-2 is finished.
Thread-0 is finished.
可以看到，所有线程都到达屏障点后，才会执行屏障点后面的代码。然后所有线程都顺利执行完成。

下面是一个使用同步队列的示例代码：
import java.util.concurrent.SynchronousQueue;
public class SynchronousQueueDemo {
    public static void main(String[] args) {
        SynchronousQueue<Integer> queue = new SynchronousQueue<>();
        new Thread(() -> {
            try {
                int data = queue.take(); // 等待另一个线程放入数据
                System.out.println("Received data: " + data);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
        new Thread(() -> {
            int data = 123;
            try {
                queue.put(data); // 等待另一个线程取走数据
                System.out.println("Sent data: " + data);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
    }
}
在上面的代码中，首先创建了一个SynchronousQueue对象，然后创建了两个线程。第一个线程调用take()方法等待另一个线程放入数据，第二个线程调用put()方法将数据放入队列中。当第二个线程放入数据后，第一个线程就会从take()方法中返回，并输出接收到的数据。
运行上面的代码，可以看到输出结果如下：
Sent data: 123
Received data: 123
可以看到，第二个线程先将数据放入队列中，然后第一个线程才从take()方法中返回，接收到了数据。这就是同步队列的使用方式。

下面是一个使用阻塞队列的示例代码：
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ArrayBlockingQueue;
 public class BlockingQueueDemo {
    public static void main(String[] args) {
        BlockingQueue<Integer> queue = new ArrayBlockingQueue<>(10); // 创建一个大小为10的阻塞队列
        new Thread(() -> {
            try {
                while (true) {
                    int data = queue.take(); // 从队列中取出数据，如果队列为空则阻塞线程
                    System.out.println("Received data: " + data);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
        new Thread(() -> {
            try {
                for (int i = 0; i < 20; i++) {
                    queue.put(i); // 往队列中添加数据，如果队列已满则阻塞线程
                    System.out.println("Sent data: " + i);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
    }
}
在上面的代码中，首先创建了一个大小为10的阻塞队列，然后创建了两个线程。第一个线程不断从队列中取出数据，并输出接收到的数据；第二个线程往队列中添加数据，并输出发送的数据。由于队列的大小为10，第二个线程添加了20个数据，因此它会在添加第10个数据时阻塞，等待第一个线程取出数据后再继续添加数据。
 运行上面的代码，可以看到输出结果如下：
Sent data: 0
Received data: 0
Sent data: 1
Received data: 1
Sent data: 2
Received data: 2
Sent data: 3
Received data: 3
Sent data: 4
Received data: 4
Sent data: 5
Received data: 5
Sent data: 6
Received data: 6
Sent data: 7
Received data: 7
Sent data: 8
Received data: 8
Sent data: 9
Received data: 9
Sent data: 10
Received data: 10
Sent data: 11
Received data: 11
Sent data: 12
Received data: 12
Sent data: 13
Received data: 13
Sent data: 14
Received data: 14
Sent data: 15
Received data: 15
Sent data: 16
Received data: 16
Sent data: 17
Received data: 17
Sent data: 18
Received data: 18
Sent data: 19
Received data: 19
可以看到，第二个线程先往队列中添加了0~9这10个数据，然后阻塞等待第一个线程取出数据。当第一个线程取出数据后，第二个线程才继续添加数据。这就是阻塞队列的使用方式。

例如：
public class MyThreadLocal {
    private static ThreadLocal<Integer> threadLocal = new ThreadLocal<Integer>() {
        @Override
        protected Integer initialValue() {
            return 0;
        }
    };
     public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            threadLocal.set(1);
            System.out.println(Thread.currentThread().getName() + ": " + threadLocal.get());
        });
         Thread t2 = new Thread(() -> {
            threadLocal.set(2);
            System.out.println(Thread.currentThread().getName() + ": " + threadLocal.get());
        });
         t1.start();
        t2.start();
    }
}
在上面的例子中，我们使用ThreadLocal类创建了一个线程局部变量，初始值为0。然后创建了两个线程，分别设置了该变量的值，并获取了该变量的值。由于每个线程都有自己的一份副本，因此它们之间的操作互不干扰，输出结果为：
Thread-0: 1
Thread-1: 2
通过使用线程局部变量，可以在多线程环境下保持数据的独立性，避免数据竞争和冲突，提高程序的并发性能。