Java 多线程

圆咕噜咕噜  金牌会员 | 4 天前 | 显示全部楼层 | 阅读模式
打印 上一主题 下一主题
楼主

主题 892|帖子 892|积分 2676

Java 多线程

1. 多线程基础概念

什么是线程？



  • 线程（Thread）：程序执行的最小单位，一个历程（如一个 Java 程序）可以包含多个线程。
  • 多线程的优势：

    • 进步 CPU 利用率（如后台使命与 UI 线程分离）。
    • 简化复杂使命的逻辑（如并行处置惩罚）。

单线程 vs 多线程



  • 单线程：按顺序执行使命（如逐行执行代码）。
  • 多线程：同时执行多个使命（如同时下载多个文件）。
2. 线程的创建与启动

2.1 继承 Thread 类

  1. public class MyThread extends Thread {
  2.     @Override
  3.     public void run() {
  4.         System.out.println("线程执行：" + Thread.currentThread().getName());
  5.     }
  7.     public static void main(String[] args) {
  8.         MyThread thread = new MyThread();
  9.         thread.start(); // 启动线程（自动调用 run()）
  10.     }
  11. }
复制代码
2.2 实现 Runnable 接口（推荐）

  1. public class MyRunnable implements Runnable {
  2.     @Override
  3.     public void run() {
  4.         System.out.println("线程执行：" + Thread.currentThread().getName());
  5.     }
  7.     public static void main(String[] args) {
  8.         Thread thread = new Thread(new MyRunnable());
  9.         thread.start();
  10.     }
  11. }
复制代码
2.3 使用 Callable 和 Future（带返回值）

  1. import java.util.concurrent.*;
  3. public class MyCallable implements Callable<Integer> {
  4.     @Override
  5.     public Integer call() throws Exception {
  6.         return 42;
  7.     }
  9.     public static void main(String[] args) throws ExecutionException, InterruptedException {
  10.         ExecutorService executor = Executors.newSingleThreadExecutor();
  11.         Future<Integer> future = executor.submit(new MyCallable());
  12.         System.out.println("结果：" + future.get()); // 阻塞直到获取结果
  13.         executor.shutdown();
  14.     }
  15. }
复制代码
2.4 Lambda 简化写法

  1. new Thread(() -> System.out.println("Lambda 线程")).start();
复制代码
3. 线程的生命周期

线程的 6 种状态（通过 Thread.getState() 查看）：
状态描述NEW线程已创建但未启动（未调用 start()）。RUNNABLE线程正在运行或等候 CPU 调度。BLOCKED线程等候锁（如 synchronized 代码块）。WAITING无穷期等候（如调用 wait()）。TIMED_WAITING有限期等候（如调用 sleep(1000)）。TERMINATED线程执行完毕或被停止。
4. 线程同步与锁

4.1 synchronized 关键字



  • 作用：确保同一时间只有一个线程访问共享资源。
  • 使用方式：

    • 修饰实例方法：锁是当前实例对象。
    • 修饰静态方法：锁是类的 Class 对象。
    • 修饰代码块：锁是手动指定的对象。

  1. public class SyncCounter {
  2.     private int count = 0;
  4.     public synchronized void increment() {
  5.         count++; // 线程安全操作
  6.     }
  8.     public static void main(String[] args) throws InterruptedException {
  9.         SyncCounter counter = new SyncCounter();
  10.         Thread t1 = new Thread(() -> { for (int i=0; i<10000; i++) counter.increment(); });
  11.         Thread t2 = new Thread(() -> { for (int i=0; i<10000; i++) counter.increment(); });
  12.         t1.start(); t2.start(); t1.join(); t2.join();
  13.         System.out.println(counter.count); // 输出 20000
  14.     }
  15. }
复制代码
4.2 ReentrantLock（可重入锁）

  1. import java.util.concurrent.locks.*;
  3. public class LockCounter {
  4.     private int count = 0;
  5.     private final ReentrantLock lock = new ReentrantLock();
  7.     public void increment() {
  8.         lock.lock();
  9.         try {
  10.             count++;
  11.         } finally {
  12.             lock.unlock(); // 确保锁释放
  13.         }
  14.     }
  15. }
复制代码
5. 线程间通讯

5.1 wait() 和 notify()



  • wait()：释放锁并进入等候状态。
  • notify()：叫醒一个等候线程。
  • notifyAll()：叫醒全部等候线程。
  1. public class WaitNotifyDemo {
  2.     private static final Object lock = new Object();
  3.     private static boolean isProduced = false;
  5.     public static void main(String[] args) {
  6.         // 生产者
  7.         new Thread(() -> {
  8.             synchronized (lock) {
  9.                 System.out.println("生产者：生产了一个产品");
  10.                 isProduced = true;
  11.                 lock.notify(); // 唤醒消费者
  12.             }
  13.         }).start();
  15.         // 消费者
  16.         new Thread(() -> {
  17.             synchronized (lock) {
  18.                 while (!isProduced) {
  19.                     try {
  20.                         System.out.println("消费者：等待产品...");
  21.                         lock.wait(); // 释放锁并等待
  22.                     } catch (InterruptedException e) {
  23.                         e.printStackTrace();
  24.                     }
  25.                 }
  26.                 System.out.println("消费者：消费了产品");
  27.             }
  28.         }).start();
  29.     }
  30. }
复制代码
5.2 BlockingQueue（壅闭队列）

  1. import java.util.concurrent.*;
  3. public class BlockingQueueDemo {
  4.     public static void main(String[] args) {
  5.         BlockingQueue<Integer> queue = new ArrayBlockingQueue<>(10);
  7.         // 生产者
  8.         new Thread(() -> {
  9.             try {
  10.                 queue.put(1); // 阻塞直到队列有空位
  11.                 System.out.println("生产了 1");
  12.             } catch (InterruptedException e) {
  13.                 e.printStackTrace();
  14.             }
  15.         }).start();
  17.         // 消费者
  18.         new Thread(() -> {
  19.             try {
  20.                 Integer item = queue.take(); // 阻塞直到队列有数据
  21.                 System.out.println("消费了 " + item);
  22.             } catch (InterruptedException e) {
  23.                 e.printStackTrace();
  24.             }
  25.         }).start();
  26.     }
  27. }
复制代码
6. 线程池

6.1 为什么须要线程池？



  • 资源开销：频繁创建和销毁线程本钱高。
  • 管理线程：统一管理线程的生命周期和数目。
6.2 使用 Executors 创建线程池

  1. import java.util.concurrent.*;
  3. public class ThreadPoolDemo {
  4.     public static void main(String[] args) {
  5.         ExecutorService executor = Executors.newFixedThreadPool(2);
  7.         for (int i=0; i<5; i++) {
  8.             executor.submit(() -> {
  9.                 System.out.println("任务由线程执行：" + Thread.currentThread().getName());
  10.             });
  11.         }
  13.         executor.shutdown(); // 关闭线程池
  14.     }
  15. }
复制代码
6.3 自界说线程池

  1. ThreadPoolExecutor customPool = new ThreadPoolExecutor(
  2.     2, // 核心线程数
  3.     4, // 最大线程数
  4.     60, // 空闲线程存活时间（秒）
  5.     TimeUnit.SECONDS,
  6.     new ArrayBlockingQueue<>(10), // 任务队列
  7.     new ThreadPoolExecutor.AbortPolicy() // 拒绝策略
  8. );
复制代码
7. 高级并发工具类

7.1 CountDownLatch（倒计时门闩）

  1. public class CountDownLatchDemo {
  2.     public static void main(String[] args) throws InterruptedException {
  3.         CountDownLatch latch = new CountDownLatch(3);
  5.         for (int i=0; i<3; i++) {
  6.             new Thread(() -> {
  7.                 System.out.println("子线程完成");
  8.                 latch.countDown(); // 计数器减 1
  9.             }).start();
  10.         }
  12.         latch.await(); // 等待计数器归零
  13.         System.out.println("所有子线程完成");
  14.     }
  15. }
复制代码
7.2 CyclicBarrier（循环栅栏）

  1. public class CyclicBarrierDemo {
  2.     public static void main(String[] args) {
  3.         CyclicBarrier barrier = new CyclicBarrier(3, () ->
  4.             System.out.println("所有线程到达栅栏"));
  6.         for (int i=0; i<3; i++) {
  7.             new Thread(() -> {
  8.                 try {
  9.                     System.out.println("线程等待");
  10.                     barrier.await(); // 等待其他线程
  11.                 } catch (Exception e) {
  12.                     e.printStackTrace();
  13.                 }
  14.             }).start();
  15.         }
  16.     }
  17. }
复制代码
7.3 Semaphore（信号量）

  1. public class SemaphoreDemo {
  2.     public static void main(String[] args) {
  3.         Semaphore semaphore = new Semaphore(3); // 允许 3 个线程同时访问
  5.         for (int i=0; i<5; i++) {
  6.             new Thread(() -> {
  7.                 try {
  8.                     semaphore.acquire(); // 获取许可
  9.                     System.out.println("线程进入");
  10.                     Thread.sleep(1000);
  11.                 } catch (InterruptedException e) {
  12.                     e.printStackTrace();
  13.                 } finally {
  14.                     semaphore.release(); // 释放许可
  15.                 }
  16.             }).start();
  17.         }
  18.     }
  19. }
复制代码
8. 原子操纵与无锁编程

8.1 原子类（AtomicInteger）

  1. import java.util.concurrent.atomic.*;
  3. public class AtomicDemo {
  4.     private AtomicInteger count = new AtomicInteger(0);
  6.     public void increment() {
  7.         count.incrementAndGet(); // 原子操作
  8.     }
  10.     public static void main(String[] args) {
  11.         AtomicDemo demo = new AtomicDemo();
  12.         // 多线程安全操作
  13.     }
  14. }
复制代码
8.2 LongAdder（高性能计数器）

  1. import java.util.concurrent.atomic.LongAdder;
  3. public class LongAdderDemo {
  4.     private LongAdder adder = new LongAdder();
  6.     public void increment() {
  7.         adder.increment();
  8.     }
  10.     public long get() {
  11.         return adder.sum();
  12.     }
  13. }
复制代码
9. 常见题目与最佳实践

9.1 怎样避免死锁？



  • 死锁条件：互斥、持有并等候、不可抢占、循环等候。
  • 办理方案：

    • 按固定顺序获取锁。
    • 使用 tryLock 设置超时时间。

9.2 性能优化发起



  • 减少锁的粒度（如使用分段锁）。
  • 优先使用无锁数据结构（如 ConcurrentHashMap）。
9.3 ThreadLocal（线程局部变量）

  1. public class ThreadLocalDemo {
  2.     private static ThreadLocal<Integer> threadLocal = ThreadLocal.withInitial(() -> 0);
  4.     public static void main(String[] args) {
  5.         new Thread(() -> {
  6.             threadLocal.set(1);
  7.             System.out.println(threadLocal.get()); // 输出 1
  8.         }).start();
  10.         new Thread(() -> {
  11.             System.out.println(threadLocal.get()); // 输出 0
  12.         }).start();
  13.     }
  14. }
复制代码
10. 总结

总结



  • 核心概念：线程、同步、通讯、线程池。
  • 关键工具：synchronized、ReentrantLock、BlockingQueue、CountDownLatch。
  • 最佳实践：避免死锁、优先使用线程池、利用原子类。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。
回复

使用道具 举报

0 个回复

倒序浏览
返回列表

快速回复

高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 or 立即注册

本版积分规则

圆咕噜咕噜

金牌会员
这个人很懒什么都没写!

楼主热帖

标签云

挺好的 服务器
微信订阅号
微信服务号
微信客服
小程序
H5
关于我们 商务合作 网站地图
©Copyright 2022-2024 杭州祥升科技有限公司 版权所有 浙ICP备20004199号
快速回复 返回顶部 返回列表