创建线程

更新: 1/19/2026 字数: 0 字 时长: 0 分钟

Thread

Thread 创建线程方式：创建线程类、匿名内部类方式

• start() 方法底层其实是给 CPU 注册当前线程，并且触发 run() 方法执行
• 线程的启动必须调用 start() 方法，如果线程直接调用 run() 方法，相当于变成了普通类的执行，此时主线程将只有执行该线程
• 为了观察子线程的并发执行效果，通常会将主线程自身较长的任务放在子线程启动之后，否则主线程可能在子线程开始执行前就已经完成

Thread 构造器：

• public Thread()
• public Thread(String name)

public class ThreadDemo {
    public static void main(String[] args) {
        Thread t = new MyThread();
        t.start();
        for(int i = 0 ; i < 100 ; i++ ){
            System.out.println("main 线程" + i);
        }
        // 如果将 main 线程的循环放在 t.start() 之前，那么 main 线程的循环会先完全执行完，之后子线程才可能开始或继续执行。
        // 如果放在 t.start() 之后（如当前代码），main 线程和子线程是并发执行的，输出会交错。
    }
}

class MyThread extends Thread {
    @Override
    public void run() {
        for(int i = 0 ; i < 100 ; i++ ) {
            System.out.println("子线程输出："+i);
        }
    }
}

继承 Thread 类的优缺点：

• 优点：编码简单
• 缺点：线程类已经继承了 Thread 类无法继承其他类了，功能不能通过继承拓展（单继承的局限性）

Runnable

Runnable 创建线程方式：创建线程类、匿名内部类方式

Thread 的构造器：

• public Thread(Runnable target)
• public Thread(Runnable target, String name)

public class ThreadDemo {
    public static void main(String[] args) {
        Runnable target = new MyRunnable();
        Thread t1 = new Thread(target,"1 号线程");
        t1.start();
        Thread t2 = new Thread(target);
        t2.start();
    }
}

public class MyRunnable implements Runnable{
    @Override
    public void run() {
        for(int i = 0 ; i < 10 ; i++ ){
            System.out.println(Thread.currentThread().getName() + "->" + i);
        }
    }
}

Thread 类本身也是实现了 Runnable 接口，Thread 类中持有 Runnable 的属性，执行线程 run 方法底层是调用 Runnable#run：

public class Thread implements Runnable {
    private Runnable target;
    
    public void run() {
        if (target != null) {
            // 底层调用的是 Runnable 的 run 方法
            target.run();
        }
    }
}

Runnable 方式的优缺点：

• 缺点：代码复杂一点。

• 优点：

  1. 线程任务类只是实现了 Runnable 接口，可以继续继承其他类，避免了单继承的局限性
  2. 同一个线程任务对象可以被包装成多个线程对象
  3. 适合多个线程去共享同一个资源
  4. 实现解耦操作，线程任务代码可以被多个线程共享，线程任务代码和线程独立
  5. 线程池可以放入实现 Runnable 或 Callable 线程任务对象

Callable

实现 Callable 接口：

1. 定义一个线程任务类实现 Callable 接口，申明线程执行的结果类型
2. 重写线程任务类的 call() 方法，这个方法可以直接返回执行的结果
3. 创建一个 Callable 的线程任务对象
4. 把 Callable 的线程任务对象包装成一个未来任务对象
5. 把未来任务对象包装成线程对象
6. 调用线程的 start() 方法启动线程

public FutureTask(Callable<V> callable)：未来任务对象，在线程执行完后得到线程的执行结果

• FutureTask 就是 Runnable 对象，因为 Thread 类只能执行 Runnable 实例的任务对象，所以把 Callable 包装成未来任务对象
• 线程池部分详解了 FutureTask 的源码

public V get()：同步等待 task 执行完毕的结果，如果在线程中获取另一个线程执行结果，会阻塞等待，用于线程同步

• get() 线程会阻塞等待任务执行完成
• run() 执行完后会把结果设置到 FutureTask 的一个成员变量，get() 线程可以获取到该变量的值

优缺点：

• 优点：同 Runnable，并且能得到线程执行的结果
• 缺点：编码复杂

public class ThreadDemo {
    public static void main(String[] args) {
        Callable call = new MyCallable();
        FutureTask<String> task = new FutureTask<>(call);
        Thread t = new Thread(task);
        t.start();
        try {
            String s = task.get(); // 获取 call 方法返回的结果（正常/异常结果）
            System.out.println(s);
        }  catch (Exception e) {
            e.printStackTrace();
        }
    }
}

public class MyCallable implements Callable<String> {
    @Override//重写线程任务类方法
    public String call() throws Exception {
        return Thread.currentThread().getName() + "->" + "Hello World";
    }
}

贡献者

LI SIR

页面历史

最后编辑于 9 天前

查看完整历史

92ce632-feat: 更新并发编程笔记