Core Java Tutorial -- Threads in Java

2022-05-28 03:49 67阅读 0赞

Process（进程）和 Thread（线程）是执行的两个基本单元。并发编程更关心 Java 线程

0.1 Process  
0.2 Thread  
1 Java Thread Example  
1.1 Java Thread Benefits  
1.2 Java Thread Example – implementing Runnable interface  
1.3 Java Thread Example – extending Thread class  
1.4 Runnable vs Thread

# Process #

一个进程是一个独立的执行环境，它可以被看作是一个程序或应用程序。但是一个程序本身包含多个进程。Java 运行时环境作为一个单独的进程运行，其中不包含不同的类和程序作为进程。

# Thread #

线程可以称为轻量级进程。线程需要较少的资源来创建并存在于进程中，线程共享进程资源。

# Java Thread Example #

每个 Java 应用程序都至少有一个线程 - main Thread。虽然有很多其他 Java 线程在后台运行，如内存管理、系统管理、信号处理等。但从应用程序角度看 - main 是第一个 Java 线程，我们可以从中创建多个线程。

[多线程][Link 1] 指的是在单个程序中同时执行的两个或多个线程。计算机但和处理器一次能执行一个线程，而时间分割则是操作系统特性，以便在不同进程和线程之间共享处理器时间。

# Java Thread Benefits #

1.  与进程相比，Java 线程是轻量级的，创建线程需要更少的时间和资源。
2.  线程共享它们的父进程的数和代码。
3.  线程之间的上下文切换通常比进程之间消耗更少。
4.  线程互通比进程通信相对容易。

Java 提供两种以编程方式来创建一个线程。

1.  实现 `java.lang.Runnable` 接口。
2.  扩展 `java.lang.Thread` 类。

Java Thread Example – implementing Runnable interface

为了让一个类可以运行，我们可以实现 `java.lang.Runnable` 接口，并在 `public void run()` 方法中提供实现。要将此类作为线程，我们需要通过传递此可运行类的对象来创建一个线程对象，然后调用 `start()` 方法在单独的线程中执行 `run()` 方法。

实现 Runnable 接口的线程栗子：

package Thread;
    
    public class HeavyWorkRunnable implements Runnable { 
    
        @Override
        public void run() {
            System.out.println("Doing heavy processing - START " + Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
                // Get database connection, delete unused data from DB
                doDBProcessing();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Doing heavy processing - END " + Thread.currentThread().getName());
        }
    
        private void doDBProcessing() throws InterruptedException {
            Thread.sleep(5000);
        }
    }

# Java Thread Example – extending Thread class #

我们可以扩展 `java.lang.Thread` 类来创建我们自己的 Java 线程类并 Override `run()` 方法。然后我们可以创建它的对象并调用 `start()` 方法来执行我们自定义的 Java 线程类 `run` 方法。

扩展 Thread 类的线程栗子：

package Thread;
    
    public class MyThread extends Thread { 
    
        public MyThread(String name) {
            super(name);
        }
    
        @Override
        public void run() {
            System.out.println("MyThread - START " + Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
                //Get database connection, delete unused data from DB
                doDBProcessing();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("MyThread - END " + Thread.currentThread().getName());
        }
    
        private void doDBProcessing() throws InterruptedException {
            Thread.sleep(5000);
        }
    }

这是展示怎么去创建一个 Java 线程并执行的测试程序：

package Thread;
    
    public class ThreadRunExample {
        public static void main(String[] args) {
            Thread t1 = new Thread(new HeavyWorkRunnable(), "t1");
            Thread t2 = new Thread(new HeavyWorkRunnable(), "t2");
            System.out.println("Starting Runnable threads");
            t1.start();
            t2.start();
            System.out.println("Runnable Threads has been started");
            Thread t3 = new MyThread("t3");
            Thread t4 = new MyThread("t4");
            System.out.println("Starting MyThreads");
            t3.start();
            t4.start();
            System.out.println("MyThreads has been started");
        }
    }

输出：

Starting Runnable threads
    Runnable Threads has been started
    Starting MyThreads
    MyThreads has been started
    Doing heavy processing - START t1 Doing heavy processing - START t2 MyThread - START t3 MyThread - START t4 Doing heavy processing - END t2 Doing heavy processing - END t1 MyThread - END t4 MyThread - END t3

一旦我们启动任何线程，它的执行取决于操作系用的时间片实现。不过，我们可以将线程设置优先级，但即使如此，也不能保证优先级高的线程将首先执行。

多次运行上面的程序，你将会发现线程的开始和结束没有模式。

# Runnable vs Thread #

如果你的类提供了更多的功能，而不是像 Thread 一样运行，你应该实现 Runnuable 接口来提供一种将它作为 Thread 运行的方法。如果你的类只是作为 Thread 运行的目标，那么你可以扩展 Thread 类。

实现 Runnable 是首选，因为 Java 支持实现多个接口。如果扩展 Thread 类，则不能扩展任何其他类。

Tip：你已经注意到线程没有任何返回值，但如果我们希望我们的线程执行一些处理，然后将结果返回给我们的客户端程序，请查看 [Java Callable Future][]。

从 Java 8 开始，Runnable 是一个功能接口，我们可以使用 lambda 表达式来提供它的实现，而不是使用匿名类。有关更多详细信息，请查看 [Java 8 功能接口][Java 8]。

[Link 1]: https://www.journaldev.com/1079/multithreading-in-java
[Java Callable Future]: https://www.journaldev.com/1090/java-callable-future-example
[Java 8]: https://www.journaldev.com/2763/java-8-functional-interfaces