【Java 基础】Java 线程机制

灰太狼 2024-05-04 08:04 50阅读 0赞

![在这里插入图片描述][7de275420e454e7a8e4d937175331ab8.png]

> ?**博主介绍**： 博主从事应用安全和大数据领域，有8年研发经验，5年面试官经验，Java技术专家，WEB架构师，阿里云专家博主，华为云云享专家，51CTO 专家博主

⛪️ 个人社区：[个人社区][Link 1]  
? 个人主页：[个人主页][Link 2]  
? 专栏地址： ✅ [Java 进阶之路][Java]  
?八股文专题：[剑指大厂，手撕 Java 八股文][Java 1]

#### 文章目录 ####

*   *   *  一、进程和线程的区别
         *  二、并行和串行的区别
         *  三、Java实现多线程的三种方法
         *  四、线程常用API
         *  五、设置优先级
         *  六、线程休眠
         *  七、线程让步
         *  八、线程中断
         *  九、线程唤醒
         *  十、线程守护

#### 一、进程和线程的区别 ####

Java进程和线程是多任务处理中的两个重要概念，它们有以下区别：

1.  **定义**：

*  进程（Process）：是操作系统中正在运行的一个程序的实例。每个进程都有自己的内存空间和系统资源。
 *  线程（Thread）：是进程中的一个执行单元，一个进程可以包含多个线程。线程共享进程的内存和资源。

1.  **资源占用**：

*  进程：每个进程都有独立的内存空间和系统资源，包括文件句柄、网络连接等。进程之间的切换开销较大。
 *  线程：线程共享进程的内存和资源，包括堆内存、静态变量等。线程之间的切换开销较小。

1.  **并发性**：

*  进程：进程之间是独立运行的，每个进程有自己的执行顺序和状态。进程间通信需要使用特殊的机制，如管道、消息队列等。
 *  线程：线程是轻量级的执行单元，多个线程可以共享相同的内存和资源。线程之间可以通过共享内存进行通信。

1.  **执行方式**：

*  进程：每个进程都有独立的执行流，进程间的切换由操作系统负责。
 *  线程：线程是在进程内部创建和调度的，线程间的切换由线程调度器负责。

1.  **安全性**：

*  进程：每个进程有独立的内存空间，进程间的数据是相互隔离的，一个进程的错误不会影响其他进程。
 *  线程：线程共享进程的内存空间，线程之间的数据是共享的，一个线程的错误可能会影响其他线程和进程。

总结：进程和线程都是实现多任务处理的方式，但在资源占用、并发性、执行方式和安全性等方面有所不同。选择使用进程还是线程取决于具体的应用场景和需求。

#### 二、并行和串行的区别 ####

Java中的并行和串行是指多任务处理中的不同执行方式，它们有以下区别：

1.  定义：
    
     *  并行（Parallel）：指多个任务同时进行，每个任务都在不同的处理器核心上执行。
     *  串行（Serial）：指一个任务在另一个任务完成后才能开始执行，按照顺序逐个执行。
2.  执行方式：
    
     *  并行：多个任务同时进行，各自独立执行，可以充分利用多核处理器的计算能力，提高执行效率。
     *  串行：一个任务在另一个任务完成后才能开始执行，按照顺序逐个执行，只能利用单核处理器的计算能力。
3.  并发性：
    
     *  并行：并行执行的任务之间可以相互独立，不需要等待其他任务的完成。
     *  串行：串行执行的任务必须按照顺序逐个执行，一个任务的完成依赖于前一个任务的结果。
4.  效率：
    
     *  并行：并行执行可以提高任务的执行速度和效率，特别是在处理大量数据或复杂计算时。
     *  串行：串行执行的效率相对较低，特别是在需要处理大量数据或复杂计算时，可能会导致执行时间较长。
5.  编程实现：
    
     *  并行：在Java中可以使用多线程或线程池来实现并行执行，通过将任务分配给不同的线程并发执行。
     *  串行：在Java中，任务按照顺序逐个执行，不需要特殊的编程实现。

总结：并行和串行是多任务处理中的两种不同执行方式，涉及到任务的独立性、执行顺序、效率和编程实现等方面的差异。在选择并行还是串行执行方式时，需要考虑任务的性质、执行时间和计算资源等因素。

#### 三、Java实现多线程的三种方法 ####

Java实现多线程有三种常用的方式：

1.  **继承Thread类**：创建一个继承自Thread类的子类，重写run()方法，在run()方法中定义线程要执行的任务。然后创建该子类的实例，并调用start()方法启动线程。

public class MyThread extends Thread {
        
        public void run() {
        
            // 线程要执行的任务
        }
    }
    
    public class Main {
        
        public static void main(String[] args) {
        
            MyThread thread = new MyThread();
            thread.start();
        }
    }

1.  **实现Runnable接口**：创建一个实现了Runnable接口的类，实现run()方法，在run()方法中定义线程要执行的任务。然后创建该类的实例，并将其作为参数传递给Thread类的构造方法，最后调用start()方法启动线程。

public class MyRunnable implements Runnable {
        
        public void run() {
        
            // 线程要执行的任务
        }
    }
    
    public class Main {
        
        public static void main(String[] args) {
        
            MyRunnable runnable = new MyRunnable();
            Thread thread = new Thread(runnable);
            thread.start();
        }
    }

1.  **使用线程池**：通过使用线程池可以更好地管理和复用线程资源。可以使用Executor框架提供的线程池相关类，例如ThreadPoolExecutor。创建一个线程池对象，然后将任务提交给线程池执行。

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

这三种方式都可以实现多线程，具体选择哪种方式取决于实际需求和场景。

#### 四、线程常用API ####

Java中线程的常用API有以下几个：

1.  Thread类：Java中的线程是通过Thread类来表示的。Thread类提供了一些常用的方法，例如start()方法用于启动线程，run()方法用于定义线程要执行的任务，sleep()方法用于使线程暂停执行一段时间等。
2.  Runnable接口：Runnable接口定义了一个run()方法，线程可以实现该接口并重写run()方法来定义线程要执行的任务。通过实现Runnable接口，可以更灵活地使用线程，因为Java中一个类只能继承一个父类，但是可以实现多个接口。
3.  synchronized关键字：synchronized关键字用于实现线程的同步，保证多个线程对共享资源的互斥访问。可以使用synchronized关键字修饰方法或代码块，使得同一时间只有一个线程可以执行被修饰的方法或代码块。
4.  wait()、notify()和notifyAll()方法：这些方法是Object类中定义的方法，用于实现线程的等待和唤醒机制。wait()方法使得当前线程进入等待状态，直到其他线程调用notify()或notifyAll()方法唤醒它；notify()方法用于唤醒一个等待中的线程，notifyAll()方法用于唤醒所有等待中的线程。
5.  join()方法：join()方法用于等待一个线程的结束。调用该方法的线程将会被阻塞，直到被调用join()方法的线程执行完毕。
6.  yield()方法：yield()方法是一个静态方法，它使得当前线程让出CPU的使用权，让其他线程有机会执行。调用yield()方法的线程仅是暂时放弃CPU的执行，不会释放锁。
7.  sleep()方法：sleep()方法使得当前线程暂停执行一段时间。可以使用Thread类的静态方法Thread.sleep()来调用该方法。

这些是Java中线程常用的API，通过使用它们可以实现线程的创建、同步、等待和唤醒等功能。

#### 五、设置优先级 ####

在Java中，线程的优先级可以通过调用Thread类的setPriority()方法来设置。线程的优先级范围从1到10，默认优先级为5。较高优先级的线程在竞争资源时会有更高的执行概率，但并不保证绝对的执行顺序。

以下是设置线程优先级的示例代码：

Thread thread = new Thread();
    thread.setPriority(Thread.MAX_PRIORITY); // 设置线程优先级为最高

在上述示例中，我们将线程的优先级设置为最高优先级，即Thread.MAX\_PRIORITY。您还可以使用Thread类提供的其他优先级常量，如Thread.MIN\_PRIORITY（最低优先级）和Thread.NORM\_PRIORITY（默认优先级）。

需要注意的是，线程优先级的设置可能受到底层操作系统的限制，不同的操作系统可能对线程优先级的处理方式有所差异。因此，在编写应用程序时，应该谨慎使用线程优先级，并且不要过度依赖线程优先级来控制程序的执行顺序和性能。

#### 六、线程休眠 ####

在Java中，可以使用Thread类的sleep()方法来使线程进入休眠状态。该方法接受一个以毫秒为单位的参数，指定线程要休眠的时间长度。在休眠期间，线程暂停执行，但仍然保持其锁定状态和其他资源。

以下是线程休眠的示例代码：

try {
        
        Thread.sleep(1000); // 休眠1秒
    } catch (InterruptedException e) {
        
        e.printStackTrace();
    }

在上述示例中，我们使用Thread.sleep()方法使当前线程休眠1秒。需要注意的是，sleep()方法可能会抛出InterruptedException异常，因此需要使用try-catch块进行异常处理。

线程休眠的应用场景包括但不限于：

*  模拟耗时操作，以便观察多线程并发执行的效果。
 *  控制线程的执行速度，以避免对系统资源的过度占用。
 *  实现定时任务等功能。

需要注意的是，线程休眠不会保证线程在指定时间后立即恢复执行，而是在休眠时间过去后，线程会进入就绪状态，等待CPU调度。因此，线程休眠的实际休眠时间可能会略有偏差。

#### 七、线程让步 ####

在Java中，可以使用Thread类的yield()方法来使当前线程让步。调用yield()方法会暂停当前线程的执行，让出CPU资源给其他具有相同或更高优先级的线程。具体来说，yield()方法会使当前线程从运行状态转变为就绪状态，然后等待CPU调度。

以下是线程让步的示例代码：

Thread.yield();

在上述示例中，我们调用Thread.yield()方法来让当前线程让步。需要注意的是，yield()方法只是一个建议，不能保证当前线程一定会让出CPU资源，具体是否让步取决于操作系统的调度策略。

线程让步的应用场景包括但不限于：

*  在多线程环境下，合理分配CPU资源，避免某个线程长时间占用CPU而导致其他线程无法执行。
 *  提高程序的响应性，让出CPU资源给其他具有更高优先级的线程。
 *  在某些特定情况下，通过让步来协调线程的执行顺序。

需要注意的是，过度使用yield()方法可能会导致线程频繁地切换状态，从而降低程序的性能。因此，在使用yield()方法时需要谨慎评估其对程序性能的影响。

#### 八、线程中断 ####

Java中的线程是一种轻量级的执行单元，它可以独立运行并执行指定的任务。线程可以同时执行多个任务，从而实现并发编程。以下是Java线程的一些重点内容：

1.  创建线程：

*  继承Thread类：创建一个继承自Thread类的子类，并重写run()方法来定义线程执行的任务。
 *  实现Runnable接口：创建一个实现了Runnable接口的类，并实现run()方法，然后将其作为参数传递给Thread类的构造函数。

1.  启动线程：

*  调用线程对象的start()方法来启动线程。start()方法会在新的线程中调用run()方法。

1.  线程状态：

*  新建（New）：线程对象被创建，但还没有调用start()方法。
 *  就绪（Runnable）：线程可以开始执行，但还没有获得CPU资源。
 *  运行（Running）：线程正在执行。
 *  阻塞（Blocked）：线程正在等待某个条件的满足，例如等待I/O操作完成或等待锁的释放。
 *  终止（Terminated）：线程执行完毕或出现异常而终止。

1.  线程同步：

*  synchronized关键字：通过在方法或代码块中使用synchronized关键字，可以实现对共享资源的同步访问，避免多个线程同时对资源进行修改导致的数据不一致问题。
 *  Lock接口：Java提供了Lock接口及其实现类，通过Lock对象可以实现对共享资源的精确控制。

1.  线程通信：

*  wait()、notify()和notifyAll()方法：这些方法是Object类的方法，可以用于线程之间的通信。wait()方法使线程进入等待状态，notify()方法唤醒一个等待中的线程，notifyAll()方法唤醒所有等待中的线程。

1.  线程池：

*  Executor框架：Java提供了Executor框架来管理和调度线程池，通过线程池可以重复利用线程对象，提高线程的执行效率。

以上是Java线程的一些重点内容，了解这些内容可以帮助开发者正确地使用线程并处理多线程编程中的常见问题。

以下是一个Java线程中断的简单示例：

public class MyThread extends Thread {
        
        public void run() {
        
            // 模拟线程执行任务
            try {
        
                for (int i = 1; i <= 5; i++) {
        
                    System.out.println("正在执行任务 " + i);
                    Thread.sleep(1000);
                }
            } catch (InterruptedException e) {
        
                System.out.println("线程被中断");
            }
        }
        
        public static void main(String[] args) {
        
            MyThread thread = new MyThread();
            thread.start(); // 启动线程
             // 主线程等待一段时间后中断子线程
            try {
        
                Thread.sleep(3000);
                thread.interrupt(); // 中断线程
            } catch (InterruptedException e) {
        
                e.printStackTrace();
            }
        }
    }

在上面的示例中，我们创建了一个继承自Thread类的子类MyThread。在run方法中，我们模拟线程执行任务的过程，每隔1秒打印一次任务执行信息。在任务执行期间，我们使用Thread.sleep方法来模拟线程阻塞。

在主线程中，我们创建了一个MyThread对象并启动线程。然后，主线程等待3秒后调用thread.interrupt()方法中断子线程。当子线程被中断时，会抛出InterruptedException异常，我们在catch块中打印了"线程被中断"的信息。

运行这个示例，你会看到子线程在执行任务过程中被中断，并捕获了InterruptedException异常。

#### 九、线程唤醒 ####

线程可以通过使用wait()和notify()方法来进行唤醒操作。下面是一个简单的示例：

public class MyThread extends Thread {
        
        private final Object lock;
        
        public MyThread(Object lock) {
        
            this.lock = lock;
        }
        
        public void run() {
        
            synchronized (lock) {
        
                try {
        
                    System.out.println("线程开始等待");
                    lock.wait(); // 线程等待
                    System.out.println("线程被唤醒");
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
            }
        }
        
        public static void main(String[] args) {
        
            Object lock = new Object();
            MyThread thread = new MyThread(lock);
            thread.start(); // 启动线程
             // 主线程等待一段时间后唤醒子线程
            try {
        
                Thread.sleep(3000);
                synchronized (lock) {
        
                    lock.notify(); // 唤醒线程
                }
            } catch (InterruptedException e) {
        
                e.printStackTrace();
            }
        }
    }

在上面的示例中，我们创建了一个继承自Thread类的子类MyThread。在run方法中，我们使用synchronized关键字对共享的锁对象进行同步，并在锁对象上调用wait()方法使线程进入等待状态。在主线程中，我们首先创建了一个共享的锁对象，并将其传递给子线程的构造函数。然后，主线程等待3秒后，在锁对象上调用notify()方法来唤醒处于等待状态的子线程。

运行这个示例，你会看到子线程在等待状态下被唤醒，并打印了"线程被唤醒"的信息。

#### 十、线程守护 ####

在Java中，线程可以分为两种类型：用户线程和守护线程。守护线程是一种特殊类型的线程，它的作用是为其他线程提供服务和支持。当所有的用户线程结束时，守护线程会自动退出。

要创建一个守护线程，可以使用Thread类的setDaemon()方法将线程设置为守护线程。下面是一个简单的示例：

public class MyThread extends Thread {
        
        public void run() {
        
            if (isDaemon()) {
        
                System.out.println("守护线程开始运行");
                try {
        
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
                System.out.println("守护线程结束运行");
            } else {
        
                System.out.println("用户线程开始运行");
                try {
        
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
                System.out.println("用户线程结束运行");
            }
        }
        
        public static void main(String[] args) {
        
            MyThread userThread = new MyThread();
            userThread.start(); // 启动用户线程
            MyThread daemonThread = new MyThread();
            daemonThread.setDaemon(true); // 设置为守护线程
            daemonThread.start(); // 启动守护线程
             try {
        
                Thread.sleep(3000);
            } catch (InterruptedException e) {
        
                e.printStackTrace();
            }
            System.out.println("主线程结束");
        }
    }

在上面的示例中，我们创建了一个继承自Thread类的子类MyThread。在run方法中，我们根据线程是否为守护线程来执行不同的逻辑。在主线程中，我们首先创建了一个用户线程和一个守护线程，并分别启动它们。然后，主线程等待3秒后结束。

运行这个示例，你会看到用户线程会正常执行完毕，而守护线程会在主线程结束后自动退出。

>  精彩专栏推荐订阅：在下方专栏??  
>  ✅ [2023年华为OD机试真题（A卷&B卷）+ 面试指导 ][2023_OD_A_B_ _]  
>  ✅ [ 精选100套 Java 项目案例 ][_100_ Java _]  
>  ✅ [面试需要避开的坑（活动）][Link 3]  
>  ✅ [你找不到的核心代码][Link 4]  
>  ✅ [带你手撕 Spring][Spring]

> ?? 本文由激流原创，原创不易，希望大家关注、点赞、收藏，给博主一点鼓励，感谢！！！

![在这里插入图片描述][7b7478e55aa24a948b358051ef941b6a.webp_pic_center]

[7de275420e454e7a8e4d937175331ab8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/04/1133f5ea787642d8bc4ab87b9b1db29d.png
[Link 1]: https://bbs.csdn.net/forums/45c04d3f41cc4dadaf312be1d1379b45?category=10003
[Link 2]: https://jiliu.blog.csdn.net/
[Java]: https://blog.csdn.net/qq_37967783/category_9902143.html
[Java 1]: https://blog.csdn.net/qq_37967783/article/details/130940512
[2023_OD_A_B_ _]: https://blog.csdn.net/qq_37967783/category_12389634.html
[_100_ Java _]: https://blog.csdn.net/qq_37967783/category_12388267.html
[Link 3]: https://blog.csdn.net/qq_37967783/category_12380337.html
[Link 4]: https://blog.csdn.net/qq_37967783/category_12391346.html
[Spring]: https://blog.csdn.net/qq_37967783/category_12391987.html
[7b7478e55aa24a948b358051ef941b6a.webp_pic_center]: https://img-blog.csdnimg.cn/7b7478e55aa24a948b358051ef941b6a.webp#pic_center