线程的创建方式

淡淡的烟草味﹌ 2024-03-22 18:22 34阅读 0赞

**目录**

2.1 继承Thread类 重写run方法

2.2 实现Runnable接口 重写run方法

2.3 实现Callable 重写call方法，配合FutureTask

2.4 基于线程池构建线程

--------------------

线程的创建分为三种方式：

### 2.1 继承Thread类 重写run方法 ###

启动线程是调用start方法，这样会创建一个新的线程，并执行线程的任务。

如果直接调用run方法，这样会让当前线程执行run方法中的业务逻辑。

public class MiTest {
    
        public static void main(String[] args) {
            MyJob t1 = new MyJob();
            t1.start();
            for (int i = 0; i < 100; i++) {
                System.out.println("main:" + i);
            }
        }
    
    }
    class MyJob extends Thread{
        @Override
        public void run() {
            for (int i = 0; i < 100; i++) {
                System.out.println("MyJob:" + i);
            }
        }
    }

### 2.2 实现Runnable接口 重写run方法 ###

public class MiTest {
    
        public static void main(String[] args) {
            MyRunnable myRunnable = new MyRunnable();
            Thread t1 = new Thread(myRunnable);
            t1.start();
            for (int i = 0; i < 1000; i++) {
                System.out.println("main:" + i);
            }
        }
    
    }
    
    class MyRunnable implements Runnable{
    
        @Override
        public void run() {
            for (int i = 0; i < 1000; i++) {
                System.out.println("MyRunnable:" + i);
            }
    
        }
    }

最常用的方式：

*  匿名内部类方式：
    
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 1000; i++) {
                    System.out.println("匿名内部类:" + i);
                }
            }
        });
        
 *  lambda方式：
    
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                System.out.println("lambda:" + i);
            }
        });

### 2.3 实现Callable 重写call方法，配合FutureTask ###

Callable一般用于有返回结果的非阻塞的执行方法

同步非阻塞。

public class MiTest {
    
        public static void main(String[] args) throws ExecutionException, InterruptedException {
            //1. 创建MyCallable
            MyCallable myCallable = new MyCallable();
            //2. 创建FutureTask，传入Callable
            FutureTask futureTask = new FutureTask(myCallable);
            //3. 创建Thread线程
            Thread t1 = new Thread(futureTask);
            //4. 启动线程
            t1.start();
            //5. 做一些操作
            //6. 要结果
            Object count = futureTask.get();
            System.out.println("总和为：" + count);
        }
    }
    
    class MyCallable implements Callable{
    
        @Override
        public Object call() throws Exception {
            int count = 0;
            for (int i = 0; i < 100; i++) {
                count += i;
            }
            return count;
        }
    }

### 2.4 基于线程池构建线程 ###

追其底层，其实只有一种，实现Runnble