Java实现多线程

刺骨的言语ヽ痛彻心扉 2024-03-16 22:40 94阅读 0赞

## Java实现多线程的四种方式 ##

### 一、继承 Thread 类 ###

1.  创建 MyThread 类，使其继承 Thread 类并重写 run() 方法。
2.  创建 MyThread 类的实例对象，即创建一个新线程。
3.  调用 start() 方法，启动线程。

public class MyThread extends Thread {
        
        @Override
        public void run() {
        
            System.out.println(Thread.currentThread().getName());
        }
    }
    
    class TestMyThread {
        
        public static void main(String[] args) {
        
            MyThread myThread1 = new MyThread();
            myThread1.setName("Thread-1");
            MyThread myThread2 = new MyThread();
            myThread2.setName("Thread-2");
            MyThread myThread3 = new MyThread();
            myThread3.setName("Thread-3");
    
            myThread1.start();
            myThread2.start();
            myThread3.start();
        }
    }

运行结果如下：

// 第一次
    Thread-2
    Thread-1
    Thread-3
    
    // 第二次
    Thread-1
    Thread-3
    Thread-2
    
    // 第三次
    Thread-1
    Thread-3
    Thread-2

由上可见线程执行顺序具有随机性，与编写顺序无关。

### 二、实现 Runnable 接口 ###

public class MyRunnable implements Runnable {
        
        @Override
        public void run() {
        
            System.out.println(Thread.currentThread().getName());
        }
    }
    
    class TestMyRunnable {
        
        public static void main(String[] args) {
        
            MyRunnable myRunnable = new MyRunnable();
            Thread thread = new Thread(myRunnable);
            thread.start();
        }
    }

执行结果如下：

Thread-0

相比于继承 Thread 类的方法来说，实现 Runnable 接口是一个更好地选择，因为 Java 不支持多继承，但是可以实现多个接口。

有一点值得注意的是 Thread 类也实现了 Runnable 接口，这意味着构造函数 Thread(Runnable target) 不仅可以传入 Runnable 接口的对象，而且可以传入一个 Thread 类的对象，这样就可以将一个 Thread 对象中的 run() 方法交由其他线程进行调用。

### 三、实现 Callable 接口 ###

public class MyCallable implements Callable<Integer> {
        
        @Override
        public Integer call() throws Exception {
        
            int a = 6;
            int b = 9;
            System.out.println("我是通过实现 Callable 接口创建的多线程，我叫" + Thread.currentThread().getName());
            return a + b;
        }
    }
    
    class TestMyCallable {
        
        public static void main(String[] args) throws ExecutionException, InterruptedException {
        
            MyCallable myCallable = new MyCallable();
            FutureTask<Integer> futureTask = new FutureTask(myCallable);
            Thread thread = new Thread(futureTask);
            thread.start();
            System.out.println("返回值为：" + futureTask.get());
        }
    }

执行结果如下：

我是通过实现 Callable 接口创建的多线程，我叫Thread-0
    返回值为：15

FutureTask 类提供了一个 get() 方法用来获取 call() 方法的返回值，但需要注意的是调用这个方法会导致程序阻塞，必须要等到线程结束后才会得到返回值。

### 四、线程池 ###

下章介绍