创建线程的几种方式

😀大家好！我是向阳🌞，一个想成为优秀全栈开发工程师的有志青年！	
📔今天来说一说创建线程的几种方式。

1.Thread

Thread 创建线程方式：创建自定义线程类，匿名内部类方式

• start() 方法底层其实是给 CPU 注册当前线程，并且触发 run() 方法执行，start方法相当于修改线程的状态，创建线程将线程状态由 NEW 改为 RUNNABLE（包含就绪态ready和运行态running）
• 线程的启动必须调用 start() 方法，如果线程直接调用 run() 方法，相当于变成了普通类的执行，此时主线程将只有执行该线程
• 建议线程先创建子线程，主线程的任务放在之后，否则主线程（main）永远是先执行完

1.1.匿名内部类

还可以给线程设置对应的名称，当然也可以在创建线程的时候就传递name参数。例如使用这种构造器：public Thread(String name)

public class Test1 {public static void main(String[] args) {Thread t = new Thread() {@Overridepublic void run() {log.debug("running - 1");}};t.setName("t1");t.start();log.debug("running - main");}
}

或者可以这样子写，使用lambda表达式：

public class Test2 {public static void main(String[] args) {Thread t2 = new Thread(() -> log.debug("running - 2"));t2.setName("t1");t2.start();log.debug("running - main");}
}

1.2.创建自定义Thread类

继承 Thread 类的优缺点：

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

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线程输出放在上面 就变成有先后顺序了，因为是 main 线程驱动的子线程运行}
}
class MyThread extends Thread {@Overridepublic void run() {for(int i = 0 ; i < 100 ; i++ ) {System.out.println("子线程输出："+i);}}
}

2.Runnable

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

Thread 的构造器：

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

2.1.匿名内部类

public class Test2 {public static void main(String[] args) {Runnable r = new Runnable() {@Overridepublic void run() {log.debug("running");}};new Thread(r, "t2").start();}
}

或者可以这样子写，使用lambda表达式：

public class Test2 {public static void main(String[] args) {// lambda表达式写法Runnable r2 = () -> log.debug("running");new Thread(r2, "t2").start();}
}

2.2.创建自定义Runnable类

public class ThreadDemo {public static void main(String[] args) {Runnable target = new MyRunnable();Thread t1 = new Thread(target,"t1");t1.start();// 没有设置name参数，名称设置为 Thread-0Thread t2 = new Thread(target);}
}public class MyRunnable implements Runnable{@Overridepublic void run() {for(int i = 0 ; i < 10 ; i++ ){System.out.println(Thread.currentThread().getName() + "->" + i);}}
}

2.3.优缺点对比

Runnable 方式的优缺点：

• 缺点：代码复杂一点。

• 优点：

  1. 线程任务类只是实现了 Runnable 接口，可以继续继承其他类，避免了单继承的局限性

  2. 同一个线程任务对象可以被包装成多个线程对象

  3. 适合多个多个线程去共享同一个资源

  4. 实现解耦操作，线程任务代码可以被多个线程共享，线程任务代码和线程独立

  5. 线程池可以放入实现 Runnable 或 Callable 线程任务对象

3.Callable

3.1.匿名内部类

重现Callable中的call()方法。

通过 FutureTask.get() 获取返回值（会阻塞直到任务完成）

public class Test3 {public static void main(String[] args) throws ExecutionException, InterruptedException {FutureTask<Integer> task = new FutureTask<>(new Callable<Integer>() {@Overridepublic Integer call() throws Exception {log.debug("running...");Thread.sleep(2000);return 100;}});new Thread(task, "t1").start();log.debug("{}", task.get());new String();}
}

3.2.自定义Callable类

实现 Callable 接口：

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

public class MyCallable implements Callable<String> {@Overridepublic String call() throws Exception {return Thread.currentThread().getName() + ":" + "Hello";}
}

public class ThreadDemo {public static void main(String[] args) {Callable callable = new MyCallable();FutureTask futureTask = new FutureTask(callable);Thread thread = new Thread(futureTask);thread.start();try {System.out.println(futureTask.get());} catch (Exception e) {e.printStackTrace();}}
}

3.3.优缺点对比

优缺点：

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

4.扩展

Thread的run方法和Runnable的方法有什么区别呢?

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();}}
}

——👦[作者]：向阳256
——⏳[更新]：2025.5.5
——🥰本人技术有限，如果有不对指正需要更改或者有更好的方法，欢迎到评论区留言。