Java多线程

最新推荐文章于 2025-05-23 17:03:50 发布
最新推荐文章于 2025-05-23 17:03:50 发布
阅读量310 收藏
点赞数
分类专栏： Java基础 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/shyshyshyshy1/article/details/121596723
版权

一、基本概念

进程：资源（CPU、内存等）分配的基本单位，它是程序执行时的一个实例。

线程：是程序执行时的最小单位，它是进程的一个执行流。

进程与线程的区别：

  • 进程是资源分配的最小单位，线程是程序执行的最小单位；
  • 进程拥有独立的地址空间，线程共享进程中的数据，使用同一个地址空间；
  • 进程间的通信比较复杂，线程间共享同一进程下的数据；

多进程与多线程的优劣：

  • 创建进程比创建线程的开销大；
  • 进程间的通信比线程间的要慢；
  • 多进程比多线程稳定，多线程中的任何一个线程的崩溃都会导致整个进程的崩溃；

二、使用多线程

1.创建新线程

package Thread_demo;

public class CreateThread {
    public static void main(String[] args) {
        //线程启动后执行指定的代码，方法一：从Thread派生一个自定义类，然后重写run()方法
        Thread t = new MyThread();
        //start()方法会在内部自动调用run()方法
        t.start();
    }
}
class MyThread extends Thread{
    @Override
    public void run(){
        System.out.println("This is my Tread!");
    }
}
package Thread_demo;

public class CreateThread {
    public static void main(String[] args) {
        //线程启动后执行指定的代码，方法二：创建Thread实例时，传入一个Runnable实例
        Thread t = new Thread(new MyRunnable());
        t.start();
    }
}
class MyRunnable implements Runnable{
    @Override
    public void run(){
        System.out.println("This is my Tread!");
    }
}
package Thread_demo;

public class CreateThread {
    public static void main(String[] args) {
        //线程启动后执行指定的代码，方法三：使用lambda表达式
        Thread t = new Thread(()->{
            System.out.println("This is my Thread!");
        });
        t.start();
    }
}
  • 线程本身由操作系统调度，程序本身无法确定线程的调度顺序。
  • Thread.setPriority(int n) // 1~10，默认值5，优先级高的线程被操作系统调度的优先级较高，操作系统对高优先级线程可能调度更频繁，但我们决不能通过设置优先级来确保高优先级的线程一定会先执行。
package Thread_demo;

public class CreateThread {
    public static void main(String[] args) {
        System.out.println("This is the first thread start!");
        //线程启动后执行指定的代码，方法三：使用lambda表达式
        Thread t = new Thread(()->{
            System.out.println("This is the second thread start!");
            System.out.println("This is the second thread end!");
        });
        t.start();
        try {
            //可以在线程中调用Thread.sleep()强迫当前线程暂停一段时间
            Thread.sleep(10);
        }catch (InterruptedException e){}

        System.out.println("This is the first thread end!");
    }
}

2.线程状态

线程的五种状态：

  • New：新创建的线程，尚未执行；
  • Runnable：运行中的线程，正在执行run()方法的Java代码；
  • Blocked：运行中的线程，因为某些操作被阻塞而挂起；
  • Waiting：运行中的线程，因为某些操作在等待中；
  • Timed Waiting：运行中的线程，因为执行sleep()方法正在计时等待；
  • Terminated：线程已终止，因为run()方法执行完毕。

线程终止的原因：

  • 线程正常终止：run()方法执行到return语句返回；
  • 线程意外终止：run()方法因为未捕获的异常导致线程终止；
  • 对某个线程的Thread实例调用stop()方法强制终止。
package Thread_demo;

public class CreateThread {
    public static void main(String[] args) {
        System.out.println("This is the first thread start!");
        Thread t = new Thread(()->{
            System.out.println("This is the second thread start!");
            System.out.println("This is the second thread end!");
        });
        t.start();
        //个线程可以等待另一个线程直到其运行结束
        try {
            t.join();
        }catch (InterruptedException e){}
        System.out.println("This is the first thread end!");
    }
}

3.中断线程

  • 线程一给线程二发送中断请求
package Thread_demo;

public class CreateThread {
    public static void main(String[] args) {
        System.out.println("This is the first thread start!");
        Thread t = new MyThread();
        t.start();
        try {
            Thread.sleep(1);
        } catch (InterruptedException e) {}
        //给t线程发送中断请求
        t.interrupt();
        try {
            t.join();
        }catch (InterruptedException e){}
        System.out.println("This is the first thread end!");
    }
}
class MyThread extends Thread {
    @Override
    public void run(){
        int n = 0;
        while (!interrupted()) {
            n++;
            System.out.println(n);
        }
    }
}
  • 线程一给正在等待线程三中断的线程二发送中断请求
package Thread_demo;

public class CreateThread {
    public static void main(String[] args) {
        System.out.println("This is the first thread start!");
        Thread t = new MyThread();
        t.start();
        try {
            Thread.sleep(1);
        } catch (InterruptedException e) {}
        //给t线程发送中断请求
        t.interrupt();
        try {
            t.join();
        }catch (InterruptedException e){}
        System.out.println("This is the first thread end!");
    }
}
class MyThread extends Thread {
    @Override
    public void run(){
        Thread helloThread = new HelloThread();
        helloThread.start();
        try {
            helloThread.join();
        }catch (InterruptedException e){
            System.out.println("Interrupt");
        }
        helloThread.interrupt();
    }
}
class HelloThread extends Thread {
    @Override
    public void run(){
        int n = 0;
        while (!interrupted()) {
            n++;
            System.out.println(n);
        }
    }
}
  • 使用running标志位来标识线程是否应该继续运行。
  • volatile关键字是为了告诉虚拟机：每次访问变量时，总是获取主内存的最新值；每次修改变量后，立刻回写到主内存。
  • 在Java虚拟机中，变量的值保存在主内存中，但是，当线程访问变量时，它会先获取一个副本，并保存在自己的工作内存中。如果线程修改了变量的值，虚拟机会在某个时刻把修改后的值回写到主内存，但是，这个时间是不确定的。
  • volatile关键字解决的是可见性问题：当一个线程修改了某个共享变量的值，其他线程能够立刻看到修改后的值。
package Thread_demo;

public class CreateThread {
    public static void main(String[] args) {
        System.out.println("This is the first thread start!");
        MyThread t = new MyThread();
        t.start();
        try {
            Thread.sleep(1);
        } catch (InterruptedException e) {}

        t.running = false;
        try {
            t.join();
        }catch (InterruptedException e){}
        System.out.println("This is the first thread end!");
    }
}
class MyThread extends Thread {
    public volatile boolean running = true;
    @Override
    public void run(){
        System.out.println("start!");
        int n = 0;
        while (running) {
            n++;
            System.out.println(n);
        }
        System.out.println("end!");
    }
}

4.守护线程

  • 守护线程是为其他线程服务的线程；
  • 所有的非守护线程都执行完毕后，虚拟机退出；
  • 守护线程不能持有需要关闭的资源。
package Thread_demo;

public class CreateThread {
    public static void main(String[] args) {
        System.out.println("This is the first thread start!");
        MyThread t = new MyThread();
        //标记t为守护线程
        t.setDaemon(true);
        t.start();
        System.out.println("This is the first thread end!");
    }
}
class MyThread extends Thread {
    @Override
    public void run(){
        System.out.println("start!");
        int n = 0;
        while (true) {
            try {
                Thread.sleep(1000);
                n++;
                System.out.println(n);
            } catch (InterruptedException e) {
                break;
            }
        }
    }
}

5.线程同步

  • 多线程同时读写共享变量时，会造成逻辑错误，因此需要通过synchronized同步；
  • 同步的本质就是给指定对象加锁，加锁后才能继续执行后续代码，加锁对象必须是同一个实例；
  • 对JVM定义的单个原子操作不需要同步。
package threadDemo;

public class demo {
    public static void main(String[] args) {
        Thread add = new AddThread();
        Thread dec = new DecThread();
        add.start();
        dec.start();
        try {
            add.join();
        } catch (InterruptedException e) {}
        try {
            dec.join();
        } catch (InterruptedException e) {}
        System.out.println(Count.count);
    }
}
class Count{
    public static int count = 0;
    //创建一个共享实例lock
    //JVM只保证同一个锁在任意时刻只能被一个线程获取，但两个不同的锁在同一时刻可以被两个线程分别获取。
    public static final Object lock = new Object();
}
class AddThread extends Thread{
    public void run(){
        for (int i = 0; i < 1000; i++)
            //获得锁后加锁，代码块执行完毕自动释放锁
            synchronized (Count.lock
            ){
                Count.count++;
            }
    }
}
class DecThread extends Thread{
    public void run(){
        for (int i = 0; i < 1000; i++)
            synchronized (Count.lock
            ){
                Count.count--;
            }
    }
}
  • 不需要加锁的操作（JVM规范定义了几种原子操作）：

（1）基本类型（long和double除外）赋值；

（2）引用类型赋值；

6.同步方法

  • 用synchronized修饰方法可以把整个方法变为同步代码块，synchronized方法加锁对象是this；
package threadDemo;

public class demo {
    public static void main(String[] args) {
        Count c1 = new Count();
        Thread thread1 = new Thread(()->{
            c1.add(3);
        });
        thread1.start();
        try {
            thread1.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(c1.get());

        Thread thread2 = new Thread(()->{
            c1.dec(3);
        });
        thread2.start();
        try {
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(c1.get());
    }
}
class Count{
    private int count = 0;
    public void add(int n){
        synchronized (this){
            count+=n;
        }
    }
    //等价于add方法加锁
    public synchronized void dec(int n){
            count-=n;
    }
    public int get(){
        return count;
    }
}
  • 一个类被设计为允许多线程正确访问，我们就说这个类就是“线程安全”的；
  • 一个类没有特殊说明，默认不是thread-safe；
  • 对static方法添加synchronized，锁住的是该类的Class实例。

7.死锁

  • JVM允许同一个线程重复获取同一个锁，这种能被同一个线程反复获取的锁，就叫做可重入锁。
  • Java的synchronized锁是可重入锁；
  • 死锁产生的条件是多线程各自持有不同的锁，并互相试图获取对方已持有的锁，导致无限等待；
  • 避免死锁的方法是多线程获取锁的顺序要一致。

8.wait和notify用于多线程协调运行

package threadDemo;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Queue;

public class demo {
    public static void main(String[] args) throws InterruptedException{
        TaskQueue taskQueue = new TaskQueue();
        ArrayList<Thread> task = new ArrayList();
        //创建5个线程等待获取task
        for (int i = 0; i < 5; i++) {
            Thread t = new Thread() {
                public void run() {
                    //执行task
                    while (true) {
                        try {
                            String s = taskQueue.getTask();
                            System.out.println("execute: "+ s);
                        } catch (InterruptedException e) {
                            return;
                        }
                    }
                }
            };
            t.start();
            task.add(t);
        }
        //创建一个线程不断添加10个添加task
        Thread add = new Thread(()->{
           for (int i = 0; i < 10; i++) {
               String t = "t-" + Math.random();
               System.out.println("add: " + t);
               taskQueue.addTask(t);
               try {
                   Thread.sleep(100);
               } catch (InterruptedException e) {}
           }
        });
        add.start();
        add.join();
        Thread.sleep(100);
        for (Thread t: task){
            t.interrupt();
        }
    }
}
class TaskQueue {
    Queue<String> queue = new LinkedList<>();

    public synchronized void addTask(String s) {
        this.queue.add(s);
        //唤醒所有等待线程
        this.notifyAll();
    }

    public synchronized String getTask() throws InterruptedException{
        while (queue.isEmpty()) {
                //使线程进入等待状态
                this.wait();
        }
        return queue.remove();
    }
}

9.ReentrantLock

  • ReentrantLock可以替代synchronized锁进行同步，但获取锁更加安全；
  • 需要先获取到锁，再进入try{}代码块，最后在finally中释放锁；
  • 可以使用tryLock()尝试获取锁。
//对比
class Count1 {
    private int count;

    public void add(int n) {
        synchronized (this) {
            count += n;
        }
    }
}
class Count2 {
    private int count;
    //创建一个锁
    private final Lock lock = new ReentrantLock();

    public void add(int n) throws InterruptedException{
        //获取锁, 1s后没有获取到锁tryLock返回false
        if (lock.tryLock(1, TimeUnit.SECONDS)) {
            try {
                count += n;
            } finally {
                lock.unlock();
            }
        }
    }
}

10.Condition

  • 使用Condition对象来实现ReentrantLock的wait和notify；
class TaskQueue1 {
    private final Lock lock = new ReentrantLock();
    //必须从lock对象获取
    private final Condition condition = lock.newCondition();
    private Queue<String> queue = new LinkedList<>();

    public void add(String s) {
        lock.lock();
        try {
            queue.add(s);
            //类似于notify
            condition.signal();
        }finally {
            lock.unlock();
        }
    }
    public String get() throws InterruptedException{
        lock.lock();
        try {
            while (queue.isEmpty()) {
                //类似于wait
                condition.await();
            }
            return queue.remove();
        }finally {
            lock.unlock();
        }
    }
}
  • await()可以在等待指定时间后，没有被signal()唤醒的话，自己醒来；
if (condition.await(1, TimeUnit.SECONDS)) {
                    //其他线程唤醒
                }else {
                    //自己唤醒
                };

11.ReadWriteLock

  • ReadWriteLock只允许一个线程写入，允许多个线程在没有写入时同时读取，可以提高读取效率，适合读多写少的场景。
class Counter {
    private final ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    private final Lock rLock = readWriteLock.readLock();
    private final Lock wLock = readWriteLock.writeLock();
    private int[] counts = new int[10];

    public void inc(int i) {
        wLock.lock();
        try {
            counts[i]++;
        }finally {
            wLock.unlock();
        }
    }
    public int[] get() {
        rLock.lock();
        try {
            return Arrays.copyOf(counts, counts.length);
        }finally {
            rLock.unlock();
        }
    }
}

12.StampedLock

  • 乐观锁：乐观的估计读的过程中大概率不会有写入；
  • 悲观锁：读的过程中拒绝有写入；
  • StampedLock是不可重入锁；
package threadDemo;

import java.util.concurrent.locks.StampedLock;

public class Point {
    private final StampedLock stampedLock = new StampedLock();

    private double x;
    private double y;

    public void move(double x_a, double y_a) {
        //获取写锁
        long stamp = stampedLock.writeLock();
        try {
            x = x_a;
            y = y_a;
        }finally {
            //释放写锁
            stampedLock.unlockWrite(stamp);
        }
    }

    public double get() {
        //获得一个乐观读锁
        long stamp = stampedLock.tryOptimisticRead();
        double current_x = x;
        double current_y = y;
        //检查乐观锁读锁后是否有其他写锁发生
        if (!stampedLock.validate(stamp)) {
            //获取一个悲观锁
            stamp = stampedLock.readLock();
            try {
                current_x = x;
                current_y = y;
            }finally {
                //释放一个悲观锁
                stampedLock.unlock(stamp);
            }
        }
        return current_x + current_y;
    }
}

13.Concurrent集合

  • java.util.concurrent包提供的线程安全的并发集合可以大大简化多线程编程。

14.Atomic

  • java.util.concurrent.atomic包提供了一组原子操作的封装类。

15.线程池

Java 多线程
d18631089566的博客
08-15 3919
一，线程概述一，线程概述进程在一个操作系统中，每个独立执行的程序都可称为一个进程，也就是“正在运行的程序”。目前大部分计算机上安装的都是多任务操作系统，即能够同时执行多个应用程序。在计算机中，所有的应用程序都是由CPU执行的，对于一个CPU而言，在某个时间点只能运行一个程序，也就是说只能执行一个进程。线程每个运行的程序都是一个进程，一个进程中还可以有多个执行单元同时运行，这些执行单元可以看做程序执行的一条条线索，称为线程。操作系统中的每一个进程中都至少存在一个线程。当一个Java。
Java多线程面试题
tq02的博客
07-10 2707
线程的面试点问题
java多线程
m0_46702681的博客
06-19 2469
javajava。
万字图解Java多线程
qq_35598736的博客
09-06 6万+
前言 java多线程我个人觉得是javaSe中最难的一部分，我以前也是感觉学会了，但是真正有多线程的需求却不知道怎么下手，实际上还是对多线程这块知识了解不深刻，不知道多线程api的应用场景，不知道多线程的运行流程等等，本篇文章将使用实例+图解+源码的方式来解析java多线程。 文章篇幅较长，大家也可以有选择的看具体章节，建议多线程的代码全部手敲，永远不要相信你看到的结论，自己编码后运行出来的，才是自己的。 什么是java多线程? 进程与线程 进程 当一个程序被运行，就开启了一个进程， 比如启动了qq，w.
Java基础-Java多线程机制
来自想要赚大钱的小周同学
11-25 2089
学习目标：了解java多线程机制
Java多线程——线程同步
u010759175的专栏
12-28 3162
1.不安全的买票 //不安全的买票 //线程不安全，有负数或者多人买到同一张票 public class UnsafeBuyTicket { public static void main(String[] args) { BuyTicket buyTicket = new BuyTicket(); new Thread(buyTicket,"苦逼的我").start(); new Thread(buyTicket,"牛逼的你们").start(); new Thread(buyTic
java多线程execute_Java多线程
weixin_34704521的博客
02-16 2825
Java多线程之Executor、ExecutorService、Executors、Callable、Future与FutureTask1. 引子初学Java多线程，常使用Thread与Runnable创建、启动线程。如下例:Thread t1 = new Thread(newRunnable() {@Overridepublic voidrun() {System.out.println(Th...
Java 多线程：彻底搞懂线程池
热门推荐
孙强 Jimmy 的博客
07-09 20万+
熟悉Java多线程编程的同学都知道，当我们线程创建过多时，容易引发内存溢出，因此我们就有必要使用线程池的技术了。
java多线程使用教程
鹏鹏2077
04-25 5605
本教程介绍了Java多线程的基本知识和使用方法，包括创建线程、实现Runnable接口、继承Thread类、线程同步、线程间通信和线程池等。多线程技术可以提高程序的并发处理能力和响应速度，但同时也带来了线程安全和同步等问题，需要合理使用同步机制来保证线程安全。使用Java提供的Lock接口可以实现更加灵活和精细的线程同步。线程间通信可以使用wait()、notify()和notifyAll()方法来实现。线程池机制可以重用线程，提高了线程的利用率和效率。掌握了这些知识，可以使用Java实现高效、安全、可靠的
Java 多线程（三）—— 死锁
熵减玩家
10-15 8402
Java 死锁问题与解决方案
详解Java多线程处理List数据
08-26
详解Java多线程处理List数据 Java多线程处理List数据是指在Java编程中，使用多线程技术来处理List数据的操作。这种操作可以提高程序的执行效率和性能，特别是在处理大规模数据时。下面将详细介绍Java多线程处理List...
JAVA多线程的使用场景与注意事项总结
08-26
JAVA多线程的使用场景与注意事项总结 Java多线程是Java语言中的一种重要机制，允许程序同时执行多个任务，以提高程序的执行效率和响应速度。在Java中，多线程可以通过继承Thread类、实现Runnable接口或使用线程池来...
java多线程实现大批量数据导入源码
09-29
本项目以"java多线程实现大批量数据导入源码"为题，旨在通过多线程策略将大量数据切分，并进行并行处理，以提高数据处理速度。 首先，我们需要理解Java中的线程机制。Java通过`Thread`类来创建和管理线程。每个线程...
Java多线程Executors批量执行数据实现限流
05-20
Java多线程实现数据切割批量执行，实现限流操作。 java线程池Executors实现数据批量操作。 批量异步Executors处理数据，实现限流操作，QPS限流。 线程池调用第三方接口限流实现逻辑。 案例适合： 1.批量处理大数据。...
实战指南：理解 ThreadLocal 原理并用于Java 多线程上下文管理
张彦峰的博客
12-01 10万+
探讨如何基于实现一个高效的上下文管理组件，以解决多线程环境下的数据共享和上下文管理这些问题。通过具体的代码示例和实战展示如何为多线程编程提供一种简洁而高效的上下文管理方案。
初识C++：模版
2401_87194328的博客
05-23 554
该博客主要讲解模版的相关内容
canal实现mysql数据同步
最新发布
那些乐趣的博客
05-23 1515
1、canal下载进入页面可以选择需要安装的版本下载canal.deployer-1.1.8.tar.gz和canal.admin-1.1.8.tar.gz2、mysql同步用户创建和授权在canal-admin解压文件的conf中有一个canal_manager.sql，导入到master数据库3、canal admin安装和启动把canal.admin-1.1.8.tar.gz上传到linux解压 tar -zvxf canal.admin-1.1.8.tar.gz。
Android 14 Binderized HAL开发实战指南（AIDL版）
Deep Lee的专栏
05-23 1249
本文介绍了如何在Android 14中开发Binderized HAL服务，使用AIDL定义接口并实现HAL服务。首先，环境要求包括Android 14源码编译环境、AOSP android-14.0.0_r7分支、Soong构建系统、Java 17和NDK r25c。项目结构分为接口定义、实现层和SELinux策略。实现步骤包括定义AIDL接口、实现HAL服务、编写服务入口代码，并配置构建文件和SELinux策略。最后，通过VINTF配置确保服务在系统中可用，并提供了客户端调用示例。
JavaScript- 1.5 数据类型+变量+运算符
HRDMN的博客
05-23 1386
本文详细介绍了JavaScript的数据类型、变量声明、运算符及类型转换等基础知识，并通过代码实践帮助读者加深理解。系列文章已收录在前端专栏，适合初学者参考学习。通过点赞、关注和收藏，读者可以持续获取更新内容，支持作者继续分享优质学习资源。
Java多线程编程详解
Java多线程机制提供了强大的并发能力，允许开发者编写高效的并发程序。理解和掌握这些知识点对于Java开发人员来说至关重要，有助于在实际项目中处理复杂的并发问题，提升程序的性能和用户体验。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值