java并发编程—线程

迷南。 2023-10-12 12:08 59阅读 0赞

### 线程 ###

线程是程序执行的最小单位，是进程中的一个实体，是CPU调度和分派的基本单位。一个进程可以包含多个线程，每个线程可以并行执行不同的任务。

Java中创建线程的方式有以下4种：

1.  继承Thread类并重写run方法
2.  实现Runnable接口
3.  实现Callable接口
4.  使用线程池

#### 以下是代码举例 ####

1.  继承Thread类

继承Thread类是最简单的创建线程的方式。只需要继承Thread类并重写run()方法即可。

示例代码：

public class MyThread extends Thread {
        
        @Override
        public void run() {
        
            for (int i = 0; i < 10; i++) {
        
                System.out.println("线程1：" + i);
            }
        }
    }
    
    public class Main {
        
        public static void main(String[] args) {
        
            MyThread thread1 = new MyThread();
            thread1.start();
            for (int i = 0; i < 10; i++) {
        
                System.out.println("主线程：" + i);
            }
        }
    }

输出结果：

主线程：0
    主线程：1
    主线程：2
    主线程：3
    主线程：4
    主线程：5
    主线程：6
    主线程：7
    主线程：8
    主线程：9
    线程1：0
    线程1：1
    线程1：2
    线程1：3
    线程1：4
    线程1：5
    线程1：6
    线程1：7
    线程1：8
    线程1：9

1.  实现Runnable接口

实现Runnable接口是另一种创建线程的方式。需要实现Runnable接口并重写run()方法，然后将实现了Runnable接口的对象作为参数传递给Thread类的构造方法。

示例代码：

public class MyRunnable implements Runnable {
        
        @Override
        public void run() {
        
            for (int i = 0; i < 10; i++) {
        
                System.out.println("线程2：" + i);
            }
        }
    }
    
    public class Main {
        
        public static void main(String[] args) {
        
            MyRunnable myRunnable = new MyRunnable();
            Thread thread2 = new Thread(myRunnable);
            thread2.start();
            for (int i = 0; i < 10; i++) {
        
                System.out.println("主线程：" + i);
            }
        }
    }

输出结果：

主线程：0
    主线程：1
    主线程：2
    主线程：3
    主线程：4
    主线程：5
    主线程：6
    主线程：7
    主线程：8
    主线程：9
    线程2：0
    线程2：1
    线程2：2
    线程2：3
    线程2：4
    线程2：5
    线程2：6
    线程2：7
    线程2：8
    线程2：9

1.  实现Callable接口

实现Callable接口是最复杂的创建线程的方式。需要实现Callable接口并重写call()方法，然后将实现了Callable接口的对象作为参数传递给FutureTask类的构造方法，再将FutureTask对象作为参数传递给Thread类的构造方法。

示例代码：

public class MyCallable implements Callable<String> {
        
        @Override
        public String call() throws Exception {
        
            String result = "";
            for (int i = 0; i < 5; i++) {
        
                result += "线程3正在执行：" + i + "\n";
            }
            return result;
        }
    }
    
    public class Main {
        
        public static void main(String[] args) throws ExecutionException, InterruptedException {
        
            MyCallable myCallable = new MyCallable();
            FutureTask<String> futureTask = new FutureTask<>(myCallable);
            Thread thread3 = new Thread(futureTask);
            thread3.start();
            for (int i = 0; i < 5; i++) {
        
                System.out.println("主线程正在执行：" + i);
            }
            System.out.println(futureTask.get());
        }
    }

输出结果：

主线程正在执行：0
    线程3正在执行：0
    主线程正在执行：1
    线程3正在执行：1
    主线程正在执行：2
    线程3正在执行：2
    主线程正在执行：3
    线程3正在执行：3
    主线程正在执行：4
    线程3正在执行：4
    线程3正在执行：0
    线程3正在执行：1
    线程3正在执行：2
    线程3正在执行：3
    线程3正在执行：4

1.  使用线程池  
    在Java中，可以使用线程池来创建线程。线程池是一组预先创建的线程，这些线程可以被重复使用,使用线程池创建线程可以提高程序的性能和效率，避免频繁创建和销毁线程的开销。Java中可以使用`java.util.concurrent.Executors`类来创建线程池，具体实现如下：

public class MyRunnable implements Runnable {
        
        @Override
        public void run() {
        
            for (int i = 0; i < 5; i++) {
        
                System.out.println("线程4正在执行：" + i);
            }
        }
    }
    
    public class Main {
        
        public static void main(String[] args) {
        
            ExecutorService executorService = Executors.newFixedThreadPool(2); 创建一个线程池，包含2个线程
            MyRunnable myRunnable1 = new MyRunnable();
            MyRunnable myRunnable2 = new MyRunnable();
            executorService.execute(myRunnable1);
            executorService.execute(myRunnable2);
            for (int i = 0; i < 5; i++) {
        
                System.out.println("主线程正在执行：" + i);
            }
            executorService.shutdown();
        }
    }

输出结果：

主线程正在执行：0
    线程4正在执行：0
    线程4正在执行：1
    主线程正在执行：1
    主线程正在执行：2
    线程4正在执行：2
    主线程正在执行：3
    线程4正在执行：3
    主线程正在执行：4
    线程4正在执行：4

下面是它们的优缺点对比：

1.  继承Thread类

优点：

*  简单易用，代码量少。
 *  可以直接调用Thread类的方法，如sleep()、yield()等。

缺点：

*  继承Thread类会导致单继承的局限性，无法再继承其他类。
 *  线程与代码耦合度高，不利于代码的维护和复用。

1.  实现Runnable接口

优点：

*  实现Runnable接口可以避免单继承的局限性，可以继承其他类。
 *  线程与代码解耦，代码更加清晰。

缺点：