面试小札：Java如何实现并发编程

多线程基础
继承Thread类
定义一个类继承自 Thread 类，重写 run 方法。在 run 方法中编写线程要执行的任务逻辑。例如：
java  
class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("线程执行的任务");
    }
}
 
通过创建该类的实例，然后调用 start 方法来启动线程，如 new MyThread().start(); 。
实现Runnable接口
定义一个类实现 Runnable 接口，实现 run 方法。例如：
java  
class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("实现Runnable接口的线程任务");
    }
}
 
然后通过 Thread 类来启动线程，如 new Thread(new MyRunnable()).start(); 。这种方式更灵活，因为 Runnable 接口可以被多个类实现，并且可以通过同一个 Runnable 实例来启动多个线程。
线程池的使用
创建线程池
Java提供了 ExecutorService 接口和其实现类来管理线程池。可以使用 Executors 工厂类来创建不同类型的线程池。例如，创建一个固定大小的线程池：
java  
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ThreadPoolExample {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(5);
        for (int i = 0; i < 10; i++) {
            executor.execute(() -> {
                System.out.println("线程池中的线程执行任务");
            });
        }
        executor.shutdown();
    }
}
 
这里创建了一个固定大小为5的线程池，提交了10个任务。线程池会自动管理线程的复用，提高线程的使用效率，减少线程创建和销毁的开销。
并发集合类的使用
 ConcurrentHashMap 
这是一个线程安全的哈希表。在多线程环境下，多个线程可以同时访问和修改 ConcurrentHashMap 而不会出现数据不一致的问题。例如：
java  
import java.util.concurrent.ConcurrentHashMap;
public class ConcurrentHashMapExample {
    public static void main(String[] args) {
        ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();
        // 多个线程可以安全地调用put和get方法
        map.put("key", 1);
        System.out.println(map.get("key"));
    }
}
 
 CopyOnWriteArrayList 和 CopyOnWriteArraySet 
这些集合类在修改时会复制整个底层数组，适合读多写少的场景。例如， CopyOnWriteArrayList ：
java  
import java.util.concurrent.CopyOnWriteArrayList;
public class CopyOnWriteArrayListExample {
    public static void main(String[] args) {
        CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();
        list.add("元素");
        // 多个线程可以安全地读取列表元素
        for (String element : list) {
            System.out.println(element);
        }
    }
}
 
锁机制
 synchronized 关键字
可以用于修饰方法或者代码块。当一个线程访问被 synchronized 修饰的方法或者代码块时，其他线程需要等待该线程释放锁才能访问。例如：
java  
public class SynchronizedExample {
    private int count = 0;
    public synchronized void increment() {
        count++;
    }
    public static void main(String[] args) {
        SynchronizedExample example = new SynchronizedExample();
        // 多个线程访问increment方法会互斥
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                example.increment();
            }
        });
        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                example.increment();
            }
        });
        thread1.start();
        thread2.start();
        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(example.count);
    }
}
 
 ReentrantLock 
这是一个可重入锁，提供了比 synchronized 更灵活的锁机制。例如：
java  
import java.util.concurrent.locks.ReentrantLock;
public class ReentrantLockExample {
    private int count = 0;
    private ReentrantLock lock = new ReentrantLock();
    public void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }
    // 主方法和上面synchronized示例类似，用于测试
}
 
它可以实现公平锁和非公平锁，还可以通过 tryLock 方法尝试获取锁而不阻塞线程，提供了更多的控制功能。
原子类
例如 AtomicInteger 、 AtomicLong 等。这些原子类提供了原子操作，在多线程环境下可以保证操作的原子性。例如：
java  
import java.util.concurrent.atomic.AtomicInteger;
public class AtomicIntegerExample {
    private AtomicInteger count = new AtomicInteger(0);
    public void increment() {
        count.incrementAndGet();
    }
    // 主方法和前面类似，用于测试
}
 
 
原子类内部使用了CAS（比较并交换）操作来保证原子性，避免了使用锁带来的性能开销和死锁等问题。