多线程知识点

最新推荐文章于 2025-09-29 21:30:00 发布
原创 最新推荐文章于 2025-09-29 21:30:00 发布 · 861 阅读 · 8 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java

一、基础概念

1. 线程的定义

线程是程序执行的最小单元，一个进程可以包含多个线程，这些线程共享进程的内存空间和资源。在Java应用中，线程可以并发执行任务，提高程序的运行效率。

2. 进程 vs 线程
特性进程线程
定义独立运行的程序，具有独立地址空间进程内的执行单元，共享地址空间
资源占用较高（独立内存、文件句柄等）较低（共享进程资源）
创建/销毁开销大小
通信方式进程间通信（IPC，如管道、消息队列）共享内存、同步机制
典型场景多应用运行（如浏览器、编辑器）Web服务器、并发任务处理
3. 并发 vs 并行
  • 并发：多个任务在同一个CPU上切换执行（宏观同时）。
  • 并行：多个任务真正同时运行（多核CPU）。

二、线程的创建

1. 继承Thread类
class MyThread extends Thread {
    public void run() {
        System.out.println("Hello from thread: " + Thread.currentThread().getName());
    }
}

public class Main {
    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        t1.start();
    }
}

优缺点：

  • 优点：简单直接。
  • 缺点：无法继承其他类，扩展性差。
2. 实现Runnable接口
class MyRunnable implements Runnable {
    public void run() {
        System.out.println("Runnable is running: " + Thread.currentThread().getName());
    }
}

public class Main {
    public static void main(String[] args) {
        Thread t = new Thread(new MyRunnable());
        t.start();
    }
}

优缺点：

  • 优点：可以通过实现接口实现多线程，不受Java单继承机制的限制；代码更具可重用性，业务逻辑和线程控制分离。
  • 缺点：与继承Thread类相比，启动线程需要额外创建Thread对象。
3. 实现Callable接口（带返回值）
import java.util.concurrent.*;

class MyCallable implements Callable<Integer> {
    public Integer call() throws Exception {
        return 123;
    }
}

public class Main {
    public static void main(String[] args) {
        ExecutorService pool = Executors.newSingleThreadExecutor();
        Future<Integer> future = pool.submit(new MyCallable());
        try {
            System.out.println("Result: " + future.get());
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
        pool.shutdown();
    }
}
4. 使用Lambda表达式
public class Main {
    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            System.out.println("Lambda thread: " + Thread.currentThread().getName());
        });
        t.start();
    }
}

三、线程的生命周期

1. 生命周期状态
  • 新建（New）：线程被创建，但尚未启动。这时它还没有分配CPU时间。
  • 就绪（Runnable）：线程已经准备好等待CPU的分配，此时线程可以执行，但具体何时执行取决于线程调度器。
  • 运行（Running）：线程已经获得了CPU时间片，正在执行任务。
  • 阻塞（Blocked）：线程由于等待某些资源（如I/O操作、锁等）而暂时停止运行。当资源变得可用时，线程重新进入就绪状态。
  • 终止（Terminated）：线程已完成任务或因异常终止，生命周期结束。
2. 常用方法对生命周期的影响
  • start()：使线程进入就绪状态。
  • join()：让一个线程等待另一个线程执行完毕。
public class Main {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                System.out.println("线程执行: " + Thread.currentThread().getName());
            }
        });
        thread.start();
        thread.join();
        System.out.println("主线程继续执行");
    }
}

四、线程同步

1. 线程安全问题

当多个线程同时访问共享资源时，可能会导致数据不一致的问题，如竞态条件、死锁等。

2. 同步机制
（1）synchronized关键字
class Counter {
    private int count = 0;

    public synchronized void increment() {
        count++;
    }

    public int getCount() {
        return count;
    }
}
（2）ReentrantLock
import java.util.concurrent.locks.ReentrantLock;

class Counter {
    private int count = 0;
    private ReentrantLock lock = new ReentrantLock();

    public void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }
}
（3）volatile关键字
class VolatileExample {
    private volatile boolean flag = false;

    public void toggleFlag() {
        flag = !flag;
    }
}

五、线程间通信

1. wait() 和 notify() 方法
class MessageBox {
    private String message;
    private boolean hasMessage = false;

    public synchronized void put(String msg) throws InterruptedException {
        while (hasMessage) wait();
        message = msg;
        hasMessage = true;
        notifyAll();
    }

    public synchronized String take() throws InterruptedException {
        while (!hasMessage) wait();
        hasMessage = false;
        notifyAll();
        return message;
    }
}
2. BlockingQueue
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ArrayBlockingQueue;

class ProducerConsumer {
    private final BlockingQueue<Integer> queue = new ArrayBlockingQueue<>(10);

    public void produce() throws InterruptedException {
        for (int i = 0; i < 100; i++) {
            queue.put(i);
        }
    }

    public void consume() throws InterruptedException {
        while (true) {
            int value = queue.take();
            // 处理value
        }
    }
}

六、线程池

1. 线程池的优势
  • 减少线程创建和销毁的开销。
  • 提高程序性能。
  • 简化线程管理。
2. 创建线程池
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Main {
    public static void main(String[] args) {
        ExecutorService pool = Executors.newFixedThreadPool(4);
        pool.submit(() -> {
            System.out.println("任务由线程池处理");
        });
        pool.shutdown();
    }
}
3. 线程池核心参数
  • corePoolSize：核心线程数。
  • maximumPoolSize：最大线程数。
  • keepAliveTime：空闲线程存活时间。
  • workQueue：任务队列。

七、并发工具类

1. CountDownLatch
import java.util.concurrent.CountDownLatch;

public class Main {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch latch = new CountDownLatch(3);

        for (int i = 0; i < 3; i++) {
            new Thread(() -> {
                System.out.println("线程执行任务");
                latch.countDown();
            }).start();
        }

        latch.await();
        System.out.println("所有任务完成");
    }
}
2. CyclicBarrier
import java.util.concurrent.CyclicBarrier;

public class Main {
    public static void main(String[] args) {
        CyclicBarrier barrier = new CyclicBarrier(3, () -> {
            System.out.println("所有线程到达屏障");
        });

        for (int i = 0; i < 3; i++) {
            new Thread(() -> {
                try {
                    System.out.println("线程准备");
                    barrier.await();
                    System.out.println("线程继续执行");
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}
3. Semaphore
import java.util.concurrent.Semaphore;

public class Main {
    public static void main(String[] args) {
        Semaphore semaphore = new Semaphore(2);

        for (int i = 0; i < 5; i++) {
            new Thread(() -> {
                try {
                    semaphore.acquire();
                    System.out.println("线程获得许可");
                    Thread.sleep(1000);
                    System.out.println("线程释放许可");
                    semaphore.release();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

八、常见问题与解决方案

1. 线程安全问题
  • 问题：多个线程同时访问共享资源时，可能导致数据不一致。
  • 解决方案：使用同步机制（synchronized、ReentrantLock）、原子类（AtomicInteger等）、并发集合（ConcurrentHashMap等）。
2. 死锁
  • 问题：多个线程相互等待对方释放资源，导致程序无法继续执行。
  • 解决方案：避免锁嵌套、使用定时锁（tryLock()）、按顺序获取锁。
3. 线程饥饿
  • 问题：某些线程因为优先级低或资源竞争激烈而长时间得不到执行机会。
  • 解决方案：合理设置线程优先级、使用公平锁。
4. 上下文切换开销
  • 问题：频繁的上下文切换会降低程序的性能。
  • 解决方案：减少线程数量、使用线程池、优化任务分配。
Java多线程知识点整理（详细）
Jason_YBK的博客
07-26 1589
Java多线程知识点整理一、基本概念1.程序、进程和线程的区别2.何时需要多线程二、线程的常用创建方式1.通过继承Thread的方式创建线程创建方式：举例：2.通过实现Runnable的方式创建线程创建方式：举例：3.两种创建线程方式的区别和联系区别：联系：三、线程Thread类常用API方法四、线程的生命周期五、线程的同步1.举例说明线程同步重要性2. 同步代码块3.同步方法六、继承Thread和实现Runnable的区别七、线程安全的单例设计模式八、死锁九、线程通信1.主要API2.经典案例之：生产者与
多线程知识点整理
yingyingol
10-31 262
基本概念 多线程程序在较低的层次上扩展了多任务的概念：一个程序同时执行多个任务，通常，每一个任务称为一个线程，它是线程控制的简称。可以同时运行一个以上线程的程序称为多线程程序。 多进程与多线程的区别： 每个进程拥有自己的一整套变量，而线程则共享数据。 相关接口 •Runnable ◦ 方法 void run() ◦可由Runnable对象构成Thread，...
多线程的知识点
qq_62086657的博客
05-27 585
多线程、进程、synchronize、生产者与消费者模式、wait（）方法、sleep（）方法、线程生命周期、yield（）方法、jion（）方法、notify（）方法、线程同步与互斥、锁
多线程重要知识点
最新发布
weixin_43943624的博客
09-29 1105
程序由指令和数据组成，但这些指令要运行，数据要读写，就必须将指令加载至 CPU，数据加载至内存。在指令运行过程中还需要用到磁盘、网络等设备。进程就是用来加载指令、管理内存、管理 IO 的。当一个程序被运行，从磁盘加载这个程序的代码至内存，这时就开启了一个进程。一个线程就是一个指令流，将指令流中的一条条指令以一定的顺序交给CPU执行。一个进程之内可以分为一到多个线程。
Java多线程知识点总结
08-19
了解线程池的概念也是Java多线程编程中的一个重要知识点。线程池是一种多线程处理形式，它将线程和任务的概念分离开来，能够有效管理线程资源，减少线程创建和销毁的开销，提高程序性能。Java中可以通过Executors类...
Java多线程知识点整理.pdf
10-01
Java多线程知识点整理.pdf
63-Java多线程知识点总结1
08-08
Java多线程知识点总结 Java多线程知识点总结主要讲解了Java中多线程编程的基础知识，包括线程的启动、volatile变量、多线程共享数据、wait、notify、notifyAll等。 线程的启动 在Java中，线程的启动可以通过start...
多线程知识点（详解）
weixin_45969382的博客
09-25 549
谈谈对程序、进程、线程的理解 程序(program):是为了完成特性任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。 进程(process):是程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程:有它自身的产生、存在和消亡的过程。(如:运行中的QQ,运行中的MP3播放器;程序是静态的，进程是动态的;进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域)。 线程(thread):一个线程是进程的一个顺序执行流。 1)若一个进程同一时间并执行多个线程，就是支持多线程的
多线程知识点详解
早睡的浣熊
06-04 228
多线程 什么是线程，进程 线程是指程序在执行过程中，能够执行程序代码的一个执行单元；主要状态有四种：运行、就绪、挂起和结束。 进程是指一段正在执行的程序；进程可以有多个线程。 多线程的优点 使用多线程可以减少程序的相应时间 与进程相比，线程的创建和切换开销更小 多CPU或者多核计算机本身就具有执行多线程的能力，可以提高cpu的利用率 使用多线程可以简化程序的结构，使程序更加便于理解和维护。 多线程实现方法 继承 Thread 类，重写run()方法； 实现 Runnable 接口，并实现该接口的 ru
多线程知识点整理（一）
BeNiceman的博客
04-04 299
多线程是为了提高CPU的处理效率，也即提高程序的执行效率而引进的。因为在操作系统中CUP，内存，硬盘（IO设备）3者之间存在处理速度上的显著差异这是硬件层面无法解决的矛盾。CPU的处理速度>内存>硬盘(IO设备)，为了平衡和内存之间速度差异cpu中引入了缓存，为了能分时复用cpu引入了多线程。 多线程常用的实现方式有，继承Thread类和实现Runnable接口。 在单条件（con...
多线程知识点总结
Apple_Boy的博客
09-07 1722
文章目录进程和线程线程的状态及生命周期多线程实现的两种方式终止线程线程的优先级线程同步死锁yield与join方法的区别 进程和线程 进程： 程序在执行过程中分配和管理资源的基本单位，是一个动态概念，竞争计算机系统资源的基本单位。 线程： 是进程的一个执行单元，是进程内部的调度实体；比进程更小的独立运行的基本单位；线程也被称为轻量级进程 。 一个进程可以包含一个或多个线程，一个线程就是一个程序内部...
2020大数据面试精华：Java基础与多线程知识点总结
- **Java多线程实现**：Java提供了多种创建线程的方式，如继承Thread类、实现Runnable接口或者使用ExecutorService。理解线程同步机制（如synchronized关键字）和死锁防范至关重要。 - **锁实现**：Java中主要有 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值