java多线程（超详细！）

最新推荐文章于 2024-08-28 14:52:44 发布
最新推荐文章于 2024-08-28 14:52:44 发布
阅读量1.7k 收藏 26
点赞数 43
分类专栏： 后端 复习资料 文章标签： java 开发语言 spring boot spring intellij-idea 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74065705/article/details/140776546
版权

Java 的多线程是一种允许在一个程序中同时运行多个线程的技术。每个线程是独立的执行路径，可以并发执行，从而提高程序的效率和响应能力。

1. 线程基础

Java 中的线程可以通过继承 Thread 类或实现 Runnable 接口来创建和管理。

1.1 继承 Thread 类
class MyThread extends Thread {
    public void run() {
        System.out.println("Thread is running...");
    }
}

public class TestThread {
    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        t1.start(); // 启动线程
    }
}

run() 方法包含线程执行的代码，而 start() 方法用于启动新线程。

1.2 实现 Runnable 接口
class MyRunnable implements Runnable {
    public void run() {
        System.out.println("Thread is running...");
    }
}

public class TestRunnable {
    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();
        Thread t1 = new Thread(myRunnable);
        t1.start(); // 启动线程
    }
}

通过实现 Runnable 接口的方式可以更灵活地共享资源。

2. 线程的生命周期

线程在其生命周期中经历以下状态：

  • 新建（New）： 线程对象被创建，但还没有调用 start() 方法。
  • 就绪（Runnable）： 线程对象调用了 start() 方法，等待 CPU 调度。
  • 运行（Running）： 线程获得 CPU，开始执行 run() 方法的代码。
  • 阻塞（Blocked）： 线程因为某种原因（如等待资源、睡眠）被挂起。
  • 死亡（Dead）： 线程执行完 run() 方法，或者因异常退出。

3. 线程控制

Java 提供了一些方法来控制线程的执行：

  • sleep(long millis)：让当前线程睡眠指定的毫秒数。
  • join()：等待该线程终止，也就是说等待当前的线程结束, 才会继续执行下面的代码
  • yield()：暂停当前线程，让出 CPU 给其他线程。
  • interrupt()：中断线程。

4. 线程同步

多线程程序中可能会出现多个线程同时访问共享资源的情况，导致数据不一致的问题。为了解决这个问题，可以使用同步技术。

4.1. ReentrantLock

ReentrantLock 提供了比 synchronized 更加灵活的锁机制，可以显式地锁定和解锁。

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ReentrantLockExample {
    private final Lock lock = new ReentrantLock();
    private int count = 0;

    public void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }

    public int getCount() {
        return count;
    }
}
4.2. ReadWriteLock

ReadWriteLock 提供了一对锁，一个用于读操作，一个用于写操作。这允许多个读线程同时访问共享资源，但在写线程访问时会独占锁。

import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ReadWriteLockExample {
    private final ReadWriteLock lock = new ReentrantReadWriteLock();
    private int count = 0;

    public void increment() {
        lock.writeLock().lock();
        try {
            count++;
        } finally {
            lock.writeLock().unlock();
        }
    }

    public int getCount() {
        lock.readLock().lock();
        try {
            return count;
        } finally {
            lock.readLock().unlock();
        }
    }
}
4.3 synchronized

在方法前使用 synchronized 关键字，确保同一时间只有一个线程可以执行该方法。

class Counter {
    private int count = 0;

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

    public int getCount() {
        return count;
    }
}
4.4 同步块

同步块可以更灵活地控制需要同步的代码块，而不是整个方法。

class Counter {
    private int count = 0;

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

    public int getCount() {
        return count;
    }
}
4.5 注意事项

下面代码中的写法, 不能保证同一时间只有一个线程可以执行该方法。

因为 4.3 和 4.4 中 synchronized 的写法是根据 this 来保证同一时间只有一个线程可以执行, 但是他们的 this 是不同的。(把 “需要替换的” 换成注释上的就可以 “保证同一时间只有一个线程可以执行”)

class Worker implements Runnable {
    public static int cnt = 0;

    @Override
    public synchronized void run() {
        for (int i = 0; i < 100000; i ++) {
            cnt ++;
        }
    }
}

public class Main {
    public static void main(String[] args) throws InterruptedException {
    
//        Worker worker = new Worker();
//        Thread t1 = new Thread(worker);
//        Thread t2 = new Thread(worker);

        Thread t1 = new Thread(new Worker());	// 需要替换
        Thread t2 = new Thread(new Worker());	// 需要替换

        t1.start();
        t2.start();

        t1.join();
        t2.join();
        System.out.println(Worker.cnt);
    }
}

当然, 4.4 的代码也可以写成下面这样，这样他就是根据 lock 这个对象来保证同步的, java中的对象都可以当作lock

class Counter {
	public static final Object lock = new Object();
    private int count = 0;

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

    public int getCount() {
        return count;
    }
}

5. 线程通信

Java 提供了 wait(), notify(), notifyAll() 方法来实现线程间的通信。

  • wait()：让当前线程等待，直到其他线程调用 notify() 或 notifyAll()。
  • notify()：唤醒一个正在等待的线程。
  • notifyAll()：唤醒所有正在等待的线程。

6. 线程池

使用线程池可以有效地管理和复用线程，减少创建和销毁线程的开销。Java 提供了 Executor 框架来管理线程池。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class TestThreadPool {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(5);
        for (int i = 0; i < 10; i++) {
            executor.execute(new MyRunnable());
        }
        executor.shutdown();
    }
}

7. 高级线程工具

Java 提供了很多高级线程工具，如 Semaphore, CountDownLatch, CyclicBarrier 等，用于复杂的线程协调和同步。

7.1 Semaphore

信号量控制同时访问特定资源的线程数量。

import java.util.concurrent.Semaphore;

public class TestSemaphore {
    private static final Semaphore semaphore = new Semaphore(3);

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(new Task()).start();
        }
    }

    static class Task implements Runnable {
        public void run() {
            try {
                semaphore.acquire();
                System.out.println("Thread " + Thread.currentThread().getName() + " is accessing the resource.");
                Thread.sleep(2000);
                semaphore.release();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
7.2 CountDownLatch

允许一个或多个线程等待，直到在其他线程中执行的一组操作完成。

import java.util.concurrent.CountDownLatch;

public class TestCountDownLatch {
    private static final int THREAD_COUNT = 3;
    private static final CountDownLatch latch = new CountDownLatch(THREAD_COUNT);

    public static void main(String[] args) {
        for (int i = 0; i < THREAD_COUNT; i++) {
            new Thread(new Task()).start();
        }
        try {
            latch.await(); // 主线程等待所有子线程完成
            System.out.println("All threads have finished.");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    static class Task implements Runnable {
        public void run() {
            System.out.println("Thread " + Thread.currentThread().getName() + " is working.");
            latch.countDown(); // 计数器减一
        }
    }
}

结论

Java 多线程是一个强大且复杂的技术，需要深入理解和小心使用，以避免潜在的并发问题和死锁情况。通过合理地利用线程同步、线程通信和线程池等工具，可以编写高效且安全的多线程应用程序。

小程xy
关注
专栏目录
Java多线程（超详细！）
Bejpse的博客
06-05 153
进程是:一个应用程序（1个进程是一个软件）。线程是：一个进程中的执行场景/执行单元。注意：一个进程可以启动多个线程。eg. 对于java程序来说，当在DOS命令窗口中输入： java HelloWorld 回车之后。会先启动JVM，而JVM就是一个进程。JVM再启动一个主线程调用main方法（）。 同时再启动一个垃圾回收线程负责看护，回收垃圾。最起码，现在的java程序中至少有两个线程并发，一个是 ，一个是 。进程：可以看做是现实生活当中的公司。线程：可以看做是公司当中的某个员工。注意： 进程A和进程B的
java 多线程分配任务_Java多线程超详细教程（1）
weixin_42123296的博客
02-16 2512
java中的多线程是一个同时执行多个线程的过程。线程基本上是一个轻量级的子进程，是最小的处理单元。 多处理和多线程，都用于实现多任务处理。但是我们使用多线程而不是多处理，因为线程共享一个公共内存区域。 它们不分配单独的内存区域，因此节省了内存，并且线程之间的上下文切换花费的时间少于进程。Java多线程主要用于游戏，动画等Java多线程的优点1)它不会阻止用户，因为线程是独立的，您可以同时执行多个操...
java 多线程
07-16
有关于java 多线程的代码和文档，适合初学者，有关于java 多线程的代码和文档，适合初学者，
java多线程
m0_46702681的博客
06-19 2238
javajava。
多线程（java)
最新发布
m0_63272315的博客
08-28 1190
一个线程就是一个 "执行流". 每个线程之间都可以按照顺讯执行自己的代码. 多个线程之间 "同时" 执行 着多份代码.举个生活中的例子：想象一下你去一家咖啡店点咖啡的情景。在这个例子中，我们可以将这家咖啡店看作是一个程序，而店内的工作人员则可以视为线程。假设这家咖啡店提供两种服务：一种是现场制作咖啡，另一种是准备外卖订单。为了提高效率，咖啡店安排了两个工作人员分别负责这两项工作。：一位工作人员专门负责为现场顾客制作咖啡。当顾客下单后，这位工作人员就开始准备咖啡，并且在完成后交给顾客。
JAVA进阶学习笔记(1)：多线程
LeavingBook的博客
09-01 713
1 基本概念 1.1 程序 程序(program)是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。 1.2 进程 进程(process)是程序的一次执行过程，或是正在运行的一个程序。是一个动态 的过程：有它自身的产生、存在和消亡的过程。——生命周期 进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域 。 1.3 线程 线程(thread)，进程可进一步细化为线程，是一个程序内部的一条执行路径。 1.若一个进程同一时间并行执行多个线程，就是支持多线程的 2.线程
JAVA之多线程
maxu0808的博客
03-18 6054
一、什么是多线程 1. 线程与进程、并行与并发 进程：每个进程拥有自己的一整套变量。一个进程可以包含多个线程。 线程：线程属于进程，多个线程会存在共享数据的情况发生，也就是多个线程会共享同一块内存区域。 一个例子：打开word是一个进程，打开qq音乐又是另外一个进程，两进程之间不会互相影响（都有自己的一块内存区域）。但比如在qq音乐里一遍听歌，一遍又浏览排行榜，那就是在qq音乐这个进程里又有两个线程，它们之间会存在共享内存的情况。 并发：多线程就是并发的例子，一块CPU调度时会分为好多个时间片，每
Java多线程编程总结
weixin_34310369的博客
05-17 234
Java多线程编程总结   下面是Java线程系列博文的一个编目：   Java线程：概念与原理 Java线程：创建与启动 Java线程：线程栈模型与线程的变量 Java线程：线程状态的转换 Java线程：线程的同步与锁 Java线程：线程的交互 Java线程：线程的调度-休眠 Java线程：线程的调度-优先级 Java线程：线程的调度-让步 Jav...
Java多线程详解（超详细）_狂神说笔记完整版_项目代码_适合小白随课程学习
08-08
Java多线程详解 在Java编程中，多线程是一种重要的技术，它使得程序能够同时执行多个任务，提高系统的效率和响应性。本教程将详细讲解Java中的多线程概念，包括线程的创建、状态、同步以及高级主题，旨在帮助初学者...
Java多线程（超详细）
qq_43390466的博客
05-23 2570
多任务处理有两种：基于进程进程是一种"自包容"的运行程序，有操作系统直接管理，直接运行，有自己的地址空间，每一个进程开启都会消耗内存基于进程的特点是允许计算机同时运行多个程序基于线程在一个程序中，能独立运行的程序片段叫做“线程”，线程是进程内部单一的顺序控制流一个进程拥有多个线程。多个线程共享一个进程的内存空间基于线程的多任务处理环境中，线程是最小的处理单位。
Java多线程-知识点梳理和总结-超详细-面试知识点.docx
12-17
"Java多线程-知识点梳理和总结-超详细-面试知识点" Java多线程是Java编程语言中最基本也是最重要的概念之一。多线程编程可以提高程序的执行效率、改善用户体验和提高系统的可扩展性。但是，多线程编程也存在一些...
Java中的多线程
==Sdhjt的窝==
08-21 1156
多线程的简单实现过程： (1)将任务处理代码移到实现了Runnable接口的类的run方法中。这个接口非常简单，只有一个方法： public interface Runnable { void run(); } 实现这样一个类： class MyRunnable implements Runnable { public void run() { }
40个Java多线程问题总结（优就业JAVA分享）
HZC的专栏
12-22 916
前言 java多线程分类中写了21篇多线程的文章，21篇文章的内容很多，个人认为，学习，内容越多、越杂的知识，越需要进行深刻的总结，这样才能记忆深刻，将知识变成自己的。这篇文章主要是对多线程的问题进行总结的，因此罗列了40个多线程的问题。 这些多线程的问题，有些来源于各大网站、有些来源于自己的思考。可能有些问题网上有、可能有些问题对应的答案也有、也可能有些各位网友也都看过，但是本文写作
【Java多线程的使用详解】
Java之行
04-19 2088
Java多线程的使用详解
Java-多线程
给你更好的
04-16 492
目录 1、概念 1.1、Process与Thread 1.2、核心概念 2、创建线程的三种方式 2.1继承Thread类（方式一） 2.2、实现Runnable（方式二） 2.3、实现Callable（方式三） 3、静态代理设计模式 4、lambda_简化线程 4.1、无参lambda表达式 4.2、带参数的lambda表达式 4.3、带返回值的lambda表达式...
java多线程（超详细）
热门推荐
zdl66的博客
08-14 10万+
进程就是正在运行中的程序（进程是驻留在内存中的）是系统执行资源分配和调度的独立单位每一进程都有属于自己的存储空间和系统资源注意：进程A和进程B的内存独立不共享。
Java多线程编程：基础与实战探索
Java多线程开发是一项重要的技能，它涉及到如何合理分配和调度CPU资源，以提高系统的并发性和整体性能。通过深入学习和实践，开发者能够编写出更加灵活、高效的程序，适应不断变化的计算环境。
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值