Java基础【多线程】

最新推荐文章于 2024-08-04 11:07:52 发布
最新推荐文章于 2024-08-04 11:07:52 发布
阅读量693 收藏 18
点赞数 21
分类专栏： java学习 平时学习记录 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_61905492/article/details/137104204
版权

什么是线程

线程（Thread）是计算机科学中的一个重要概念，指的是在单个程序内部同时执行的一条独立的指令序列。简而言之，线程就是在一个进程内部并发执行的一段代码。每个线程都有自己的执行路径，可以独立地执行代码，访问内存和资源。

在操作系统中，一个进程可以包含多个线程，这些线程共享进程的资源，如内存空间、文件句柄等。相比于多个进程之间的通信和同步机制复杂度高，线程之间的通信和同步相对简单，因为它们可以直接访问共享的内存空间。

线程如何使用

创建线程并启动：

public class MyThread extends Thread {
    public void run() {
        System.out.println("线程执行中");
    }

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

线程休眠（sleep）：

public class SleepExample {
    public static void main(String[] args) {
        System.out.println("开始");
        
        try {
            Thread.sleep(2000); // 休眠2秒
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        System.out.println("结束");
    }
}

线程等待：

public class WaitExample {
    public static void main(String[] args) {
        final Object lock = new Object();

        Thread thread1 = new Thread(() -> {
            synchronized (lock) {
                System.out.println("线程1开始等待");
                try {
                    lock.wait(); // 线程1等待
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("线程1被唤醒");
            }
        });

        Thread thread2 = new Thread(() -> {
            synchronized (lock) {
                System.out.println("线程2开始唤醒");
                lock.notify(); // 唤醒等待的线程
            }
        });

        thread1.start();
        thread2.start();
    }
}

线程中断

public class InterruptExample {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            while (!Thread.currentThread().isInterrupted()) {
                System.out.println("线程执行中");
            }
            System.out.println("线程被中断");
        });

        thread.start();

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        thread.interrupt(); // 中断线程
    }
}

继承 Thread类 和 实现Runnable接口的区别

继承Thread类：

  1. 当一个类继承Thread类时，该类就成为一个线程类，直接重写run()方法来定义线程执行的逻辑。
  2. 缺点是Java不支持多重继承，如果继承了Thread类，就无法再继承其他类。
  3. 适用于简单的线程逻辑，不需要共享数据。
public class MyThread extends Thread {
    public void run() {
        System.out.println("线程执行中");
    }

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

实现Runnable接口：

  1. 当一个类实现Runnable接口时，可以在这个类中实现线程执行的逻辑，在run()方法中定义线程的行为。
  2. 可以避免Java单继承的限制，因为一个类可以实现多个接口。
  3. 适用于需要共享数据或资源的多线程场
public class MyRunnable implements Runnable {
    public void run() {
        System.out.println("线程执行中");
    }

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

线程的生命周期

新建（New）：当一个线程对象被创建但还没有开始运行时，处于新建状态。

运行（Runnable）：通过调用 start() 方法，线程进入可运行状态。此时线程可能正在运行，也可能正在等待系统资源。

阻塞（Blocked）：线程在某些条件下会进入阻塞状态，比如等待I/O操作完成或者获取锁资源。

无限期等待（Waiting）：线程进入无限期等待状态时，它会一直等待直到其他线程通知或中断它。

限期等待（Timed Waiting）：线程在限期等待状态下会等待一定的时间，超时后会自动恢复到可运行状态。

终止（Terminated）：线程执行完任务或者出现异常导致线程终止，进入终止状态。

线程的同步

线程同步是指多个线程之间协调它们的操作顺序，以确保数据的一致性和避免竞争条件。在多线程编程中，如果多个线程同时访问共享资源，就会出现竞争条件，可能导致数据不一致或者错误的结果。因此，需要使用同步机制来确保线程安全。

常见的线程同步机制包括：

互斥锁（Mutex）：通过对共享资源加锁的方式，保证同一时间只有一个线程能够访问共享资源，其他线程需要等待锁的释放。
信号量（Semaphore）：用于控制同时访问共享资源的线程数量，可以设置一个计数器来限制资源的访问。
条件变量（Condition Variable）：用于线程间的通信和协调，允许线程等待某个条件的发生。
读写锁（Read-Write Lock）：允许多个线程同时读取共享资源，但在有写操作时需要互斥排斥访问。
临界区（Critical Section）：用于限制对共享资源的访问，确保在同一时间只有一个线程可以执行临界区代码

线程如何同步

synchronized关键字：通过在方法中使用synchronized关键字或者synchronized代码块，可以确保多个线程对共享资源的访问是同步的。当一个线程获取了对象的锁之后，其他线程必须等待该线程释放锁才能继续执行。

public synchronized void synchronizedMethod() {
    // 同步方法
}

// 或者

public void someMethod() {
    synchronized(this) {
        // 同步代码块
    }
}

Lock接口： Java中的java.util.concurrent.locks包提供了Lock接口及其实现类，如ReentrantLock。与synchronized不同，Lock接口提供了更灵活的锁定机制，包括可重入锁、公平锁等。

Lock lock = new ReentrantLock();

lock.lock();
try {
    // 同步代码块
} finally {
    lock.unlock();
}

volatile关键字：在Java中，volatile关键字用于声明变量，保证了变量的可见性，并禁止指令重排序优化。尽管volatile关键字不能取代锁机制，但它可以在特定情况下用来确保共享变量的同步访问。

private volatile boolean flag = false;

Synchronize

使用 synchronized 关键字来实现线程同步，确保多个线程访问共享资源时的安全性。通过在方法上或代码块中添加
synchronized 关键字，可以将方法或代码块标记为同步的，这样只有一个线程能够访问该方法或代码块，其他线程需要等待

public class SynchronizedExample {
    private int count = 0;

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

    public static void main(String[] args) {
        SynchronizedExample syncExample = new SynchronizedExample();

        // 创建两个线程分别对 count 执行增加操作
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                syncExample.increment();
            }
        });

        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                syncExample.increment();
            }
        });

        thread1.start();
        thread2.start();

        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Final Count: " + syncExample.getCount());
    }

    public synchronized int getCount() {
        return count;
    }
}

synchronized 关键字：

特点：synchronized 是 Java 语言提供的内置机制，可以用来实现线程同步，通过对代码块或方法加锁来确保同一时间只有一个线程可以执行该代码块或方法。
优点：简单易用，不需要显式地创建锁对象；可以确保每次只有一个线程访问共享资源。
缺点：灵活性较差，只能实现基本的互斥同步，不能支持尝试获取锁、超时等特性。
ReentrantLock 类：

特点：ReentrantLock 是 Lock 接口的实现类，提供了比 synchronized 更灵活的锁定机制，可以支持可重入锁、公平性设置、尝试获取锁、超时获取锁等功能。
优点：比 synchronized 更灵活，可以支持更多高级特性；可以避免死锁情况。
缺点：使用复杂一些，需要手动释放锁，并且需要注意异常处理。

AtomicInteger 类：

特点：AtomicInteger 是 java.util.concurrent.atomic 包下的原子操作类，提供了一种线程安全的整数类型，支持原子性的增减操作。
优点：适用于简单的原子操作，不需要显式加锁，性能较好。
缺点：只适用于特定类型的原子操作，不适用于复杂的同步场景。

互斥锁

互斥锁（Mutex
Lock）是一种用于确保在多线程环境中不会同时执行特定代码段的同步机制。当一个线程获得了互斥锁时，其他线程就无法再获取该锁，直到持有锁的线程释放它为止。
一般情况下，使用互斥锁的基本流程如下：

当一个线程希望访问共享资源时，它尝试获取互斥锁。
如果互斥锁已经被其他线程持有，则当前线程将被阻塞，直到互斥锁被释放。
一旦获取了互斥锁，线程就可以安全地访问共享资源。
当线程不再需要访问共享资源时，它会释放互斥锁，以便其他线程可以获取并访问共享资源。

当使用synchronized关键字或ReentrantLock类时，都可以实现互斥锁

使用synchronized关键字实现互斥锁：

public class SynchronizedMutexExample {
    private static int counter = 0;

    public static void main(String[] args) {
        Object lock = new Object(); // 创建一个对象作为锁

        Thread thread1 = new Thread(() -> {
            synchronized (lock) { // 使用lock对象进行同步
                for (int i = 0; i < 1000; i++) {
                    counter++;
                }
            }
        });

        Thread thread2 = new Thread(() -> {
            synchronized (lock) { // 使用相同的lock对象进行同步
                for (int i = 0; i < 1000; i++) {
                    counter++;
                }
            }
        });

        thread1.start();
        thread2.start();

        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Counter: " + counter);
    }
}

ps: 在使用synchronized关键字时，当线程执行完同步代码块或同步方法后，会自动释放对象锁。在synchronized块或方法结束时，系统会自动释放锁，不需要显式调用解锁的操作，这是synchronized关键字的特性之一。

使用ReentrantLock类实现互斥锁：

import java.util.concurrent.locks.ReentrantLock;

public class ReentrantLockMutexExample {
    private static int counter = 0;
    private static ReentrantLock lock = new ReentrantLock(); // 创建ReentrantLock对象作为锁

    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            lock.lock(); // 获取锁
            try {
                for (int i = 0; i < 1000; i++) {
                    counter++;
                }
            } finally {
                lock.unlock(); // 释放锁
            }
        });

        Thread thread2 = new Thread(() -> {
            lock.lock(); // 获取锁
            try {
                for (int i = 0; i < 1000; i++) {
                    counter++;
                }
            } finally {
                lock.unlock(); // 释放锁
            }
        });

        thread1.start();
        thread2.start();

        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Counter: " + counter);
    }
}

线程死锁

如果不释放锁，将导致其他线程无法获取该锁，从而造成死锁。当一个线程持有锁并且不释放锁时，其他线程就无法进入同步代码块或方法，这可能会导致所有线程都在等待获取锁而无法继续执行，最终导致程序被阻塞。

死锁是多线程编程中常见的问题，应该尽量避免。因此，一定要确保在合适的时机释放锁，以允许其他线程获得锁并执行同步代码块，从而避免死锁情况的发生。

下面我们模拟一下线程死锁：

public class DeadlockExample {
    private static Object lock1 = new Object();
    private static Object lock2 = new Object();

    public static void main(String[] args) {
        // 线程1尝试获取lock1，然后尝试获取lock2
        Thread thread1 = new Thread(() -> {
            synchronized (lock1) {
                System.out.println("Thread 1: Holding lock 1...");
                try {
                    Thread.sleep(100); // 为了让线程2有机会获取lock2
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Thread 1: Waiting for lock 2...");

                synchronized (lock2) {
                    System.out.println("Thread 1: Holding lock 1 and lock 2...");
                }
            }
        });

        // 线程2尝试获取lock2，然后尝试获取lock1
        Thread thread2 = new Thread(() -> {
            synchronized (lock2) {
                System.out.println("Thread 2: Holding lock 2...");
                try {
                    Thread.sleep(100); // 为了让线程1有机会获取lock1
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Thread 2: Waiting for lock 1...");

                synchronized (lock1) {
                    System.out.println("Thread 2: Holding lock 1 and lock 2...");
                }
            }
        });

        // 启动两个线程
        thread1.start();
        thread2.start();
    }
}

如何避免线程死锁

避免线程持有多个锁：
线程在持有一个锁的同时，尝试获取另一个锁时容易导致死锁。尽量设计避免一个线程同时持有多个锁的情况。

按固定的顺序获取锁：
多个线程都按照相同的顺序获取共享资源的锁，可以避免循环等待的情况，从而避免死锁的发生。

设置超时时间：
在获取锁的过程中设置超时时间，如果超过一定时间还未获取到锁，就放弃并释放已经获取的锁，避免长时间等待导致死锁。

使用并发工具类：
Java提供了一些并发工具类，如java.util.concurrent包下的工具类，可以更方便地管理线程之间的资源竞争，避免死锁。

避免嵌套锁：
尽量避免在持有一个锁的情况下再去申请另一个锁，这样容易导致死锁的发生。

良好的代码设计：
在编写多线程程序时，要注意良好的代码设计，避免复杂的线程交互关系，减少出现死锁的可能性。

使用同步块代替同步方法：
在对共享资源进行操作时，尽量使用同步块而不是同步方法，这样可以更灵活地控制锁的获取顺序，降低死锁的风险。

CV工程师丁Sir
关注
  • 21
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java基础多线程.xmind
09-20
个人关于java基础多线程的思维导图总结。0积分下载。如果认为有帮助，请关注点赞，日后还有更多免费资源。
Java基础多线程编程
12-22
多线程编程 　1.多进程：等同于多任务，一个进程是一个独立执行的程序，在内存里独立划分一个空间，多进程不是意义上的同时，而是CPU在进程间来回的切换 　2.线程是进程内部独立执行的流程，一个进程的所有线程...
java基础之线程创建
qq_41720578的博客
06-17 179
使用 new 关键字和 Thread 类或其子类建立一个线程对象后，该线程对象就处于新建状态。它保持这个状态直到程序 start() 这个线程。当线程对象调用了start()方法之后，该线程就进入就绪状态。就绪状态的线程处于就绪队列中，要等待JVM里线程调度器的调度。如果就绪状态的线程获取 CPU 资源，就可以执行 run()，此时线程便处于运行状态。处于运行状态的线程最为复杂，它可以变为阻塞状态、就绪状态和死亡状态。如果一个线程执行了sleep（睡眠）、suspend（挂起）等方法，失去所占用资源之后，该
java创建线程的三种方式
CarveStone的博客
02-15 354
即在一个程序中可以同时运行多个不同的线程来执行不同的任务， 也就是说允许单个程序创建多个并行执行的线程来完成各自的任务。考虑道 Java 是单继承的，也就是说继承本身也是一种很宝贵的资源，因此，我们也可以使用 Runnable 接口来实现同样的操作。线程 Thread 有一个 run() 方法，start() 方法就会新建一个线程并让这个线程执行 run() 方法。Callable 规定的方法是 call()，而 Runnable 规定的方法是 run()。：不要用 run() 方法开启新线程。
Java 线程关键字
imsjw
03-12 1416
##java线程相关关键字 ####可见性 可见性是指线程之间的可见性,一个现在的装对另外一个线程是可见的 也就是说一个变量的修改后的对于其他线程而已立刻可以看见,但是不存在原子性,也就存在安全问题 ####原子性 原子是世界上最小的单位具有不可分割性 java 通常通过 synchronized 关键字保证原子性 ####有序性 即程序执行的顺序按照代码的先后顺序执行 Java内存模型中的有序性...
启动一个异步线程去执行一个任务
啊呆的博客
01-19 1万+
1.业务场景： 浦发银行充值接口，他行卡充值不是实时将充值结果返回的，需要我们自己去手动去查。银行充值接口实现业务都是预计2小时到账，但如果需求修改发送充值接口后，立马去调用银行提供的状态查询接口，将状态查询回来时，需要启动一个异步线程将结果查询回来. 代码编辑如下： <beans xmlns="http://www.springframework.org/schema/beans" xm
java中如何启动一个新的线程三种方法
u010871655的博客
09-24 2万+
java开启新线程的三种方法： 方法1：继承Thread类 1）：定义bai一个继承自Java.lang.Thread类的du类A. 2）：覆盖zhiA类Thread类中的run方法。 3）：我们编写需要在run方法中执行的操作：run方法中的代码，线程执行体。 4）：在main方法（线程）中，创建一个线程对象并启动线程。 (1)创建线程类对象: A类 a = new A类(); (2)调用线程对象的start方法: a.start();...
Java基础——多线程详解！！！！
qq_52519008的博客
10-04 4751
就是进程中的一个独立控制单元，线程在控制着进程的执行。一个进程中至少有一个进程。多线程是多任务的一种特别的形式，但多线程使用了更小的资源开销。多线程能满足程序员编写高效率的程序来达到充分利用 CPU 的目的。注意：很多多线程是模拟出来的，真正的多线程是指有多个CPU，即多核，如服务器。如果是模拟出来的多线程，即在一个CPU的情况下，在同一个时间点，CPU只执行一个代码，因为切换得很快，所以就有同时执行的错觉。程序、进程和线程的大家可以通过百度搜索得知，在这里我就不多阐述。
Java多线程实战-实现多线程文件下载，支持断点续传、日志记录等功能
热门推荐
qq_35716689的博客
03-10 18万+
本文将介绍如何通过Java来实现一个多线程下载器。作者：牵着猫散步的鼠鼠
Java多线程（超详细！）
一只小菜鸡
05-13 12万+
1、什么是进程？什么是线程？ 进程是:一个应用程序（1个进程是一个软件）。 线程是：一个进程中的执行场景/执行单元。 注意：一个进程可以启动多个线程。 eg.对于java程序来说，当在DOS命令窗口中输入： java HelloWorld 回车之后。 会先启动JVM，而JVM就是一个进程。 JVM再启动一个主线程调用main方法。 同时再启动一个垃圾回收线程负责看护，回收垃圾。 最起码，现在的java程序中至少有两个线程并发， 一个是垃圾回收线程，一个是执行main方法的主线程。 3、进程和线程是什么关系？
Java 多线程编程基础(详细)
一夜星尘
11-03 3万+
Java多线程编程基础进程与线程多线程实现Thread类实现多线程Runnable接口实现多线程Callable接口实现多线程多线程运行状态多线程常用操作方法线程的命名和获取线程休眠线程中断线程强制执行线程让步线程优先级设定线程的同步和锁死线程同步处理线程死锁 进程与线程 进程与线程的基本认识 进程（Process）：进程是程序的一次动态执行过程，它经历了从代码加载、执行、到执行完毕的一个完整过程；同时也是并发执行的程序在执行过程中分配和管理资源的基本单位，竞争计算机系统资源的基本单位。 线程（Thread
JAVA多线程基本原理
m0_58355200的博客
04-10 1835
JAVA多线程 1. 什么是线程?线程和进程的区别? 进程：进程是指处于运行过程中的程序，并且具有一定的独立功能。进程是系统进行资源分配和调度的一个单位。当一个程序进入内存运行时，就成为一个进程。 线程：线程是进程的组成部分，一个进程可以拥有多个线程，而一个线程必须拥有一个父进程。线程可以拥有自己的堆栈，自己的程序计数器和自己的局部变量，但不能拥有系统资源。它与父进程的其他线程共享该进程的所有资源。 主线程：在Java中必然有一个执行路径(线程)从main方法开始的，一直执行到main方法结束。
JAVA-多线程 所有文件
01-09
在Java编程语言中，多线程是程序设计中的一个重要概念，尤其在开发高效能和响应迅速的应用时。这个“JAVA-多线程 所有文件”压缩包很可能包含了一系列关于Java多线程学习的源代码示例和相关文档。下面我们将深入探讨...
java基础多线程
05-18
学完以后我们应该可以: 了解什么是线程 编程定义线程 编程实例化线程 知道如何启动线程 会使用同步代码来保护资源 说出线程的4个状态之间的转换关系
java基础多线程练习题（1）
08-08
总结来说，Java基础多线程练习题主要涵盖了线程的创建、同步与通信、线程安全以及并发工具的使用。通过这些题目，你可以更好地理解线程的工作原理，学会在实际项目中有效利用多线程提高程序性能，避免潜在的问题。在...
枚举工具类
qq_43049583的博客
08-04 335
java枚举工具类
等待唤醒机制两种实现方法-阻塞队列
最新发布
泰勒今天想展开的博客
08-04 370
桌子上有面条-》吃货执行桌子上没面条-》生产者制造执行。
社区养老服务小程序的设计
Karen198的博客
07-31 702
管理员账户功能包括：系统首页，个人中心，用户管理，服务人员管理，服务产品管理，服务预约管理，服务状态管理，服务退订管理，活动管理，视频管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。服务器：SpringBoot自带 apache tomcat。微信端账号功能包括：系统首页，服务产品，活动，视频，我的。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发工具：IDEA(推荐)开发系统：Windows。
深入理解Java注解
weixin_55745942的博客
08-01 691
Java注解是用来描述程序元素（如类、方法、变量等）的一种机制。它们可以提供关于程序的补充信息，帮助编译器、框架或其他工具更好地理解和处理代码。注解通常以符号开头，后跟注解名称和可能的参数。要创建自定义注解，需要使用@interface关键字定义一个接口，并在接口中声明注解的属性。这个注解名为，可以被用来标记方法。它有一个名为value的属性，具有默认值"default"。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值