java多线程实现的四种方式
创建线程方式一:继承Thread类,重写run方法,调用start开启线程
//创建线程方式一:继承Thread类,重写run方法,调用start开启线程
public class TextThread1 extends Thread {
@Override
public void run() {
//run方法线程体
for (int i = 0; i < 20; i++) {
System.out.println("我在看代码"+i);
}
}
public static void main(String[] args) {
//main 主线程
//创建一个线程对象
TextThread1 textThread1 = new TextThread1();
//调用start方法
textThread1.start();
for (int i = 0; i < 20; i++) {
System.out.println("我在学习多线程"+i);
}
}
}
运行结果:
*这里会发现我们两条线程交替执行
创建线程方式二:实现runnable接口,重写run方法,执行线程需要丢入runnable接口,调用start方法
//创建线程方式二:实现runnable接口,重写run方法,执行线程需要丢入runnable接口,调用start方法
public class TextThread2 implements Runnable {
@Override
public void run() {
//run方法线程体
for (int i = 0; i < 20; i++) {
System.out.println("我在看代码"+i);
}
}
public static void main(String[] args) {
//创建runnable接口的实现类对象
TextThread2 textThread2 = new TextThread2();
//调用线程对象,通过线程对象来开启我们的线程。代理
new Thread(textThread2).start();
for (int i = 0; i < 20; i++) {
System.out.println("我在学习多线程"+i);
}
}
}
效果:
创建线程方式三:实现callable接口
1.实现callable接口,重写call()方法
2.创建FutureTask实例,创建子线程实例
3.创建Thread实例,执行FutureTask
4.在主线程打印信息
5.获取打印的子线程执行结果
*对比之前两种方法1.无法获取子线程的返回值2.run方法不可以抛出异常
import java.util.concurrent.*;
//创建线程方式三:实现callable接口
//创建FutureTask实例,创建子线程实例
//创建Thread实例,执行FutureTask
//在主线程打印信息
//获取打印的子线程执行结果
//之前两种方法
//1.无法获取子线程的返回值
//2.run方法不可以抛出异常
public class TextThread4 implements Callable<String> {
@Override
public String call() throws Exception {
for (int i = 0; i < 10; i++) {
System.out.println("子线程执行第"+i+"次");
}
return "子线程执行完毕";
}
public static void main(String[] args) throws ExecutionException, InterruptedException {
//创建FutureTask实例,创建子线程实例
TextThread4 textThread4 = new TextThread4();
FutureTask<String> task=new FutureTask<String>(textThread4);
//创建Thread实例,执行FutureTask
Thread thread=new Thread(task,"myCallable");
thread.start();
//在主线程打印信息
for (int i = 0; i < 10; i++) {
System.out.println("main线程执行第"+i+"次");
}
//获取打印的子线程执行结果
String result=task.get();
System.out.println(result);
}
}
效果:
创建线程方式四:使用线程池创建线程
为什么要使用线程池:
如果在真实系统里面,可能会由于业务情况,开启了很多线程,当线程数量多大时,会耗尽cpu和内存资源。
比如说,创建和销毁线程也需要时间,如果创建和销毁的时间远大于线程执行的时间,反而得不偿失。其次线程也需要占用内存空间,大量的线程会抢占宝贵的内存资源,且大量的线程回收也会给GC带来很大的压力,延长GC的停顿时间。
因此,为了避免频繁的创建和销毁线程,让创建的线程进行复用,就有了线程池的概念。
线程池里会维护一部分活跃线程,如果有需要,就去线程池里取线程使用,用完即归还到线程池里,免去了创建和销毁线程的开销,且线程池也会线程的数量有一定的限制。
测试代码:
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
//使用线程池创建线程
public class TextThread6 {
public static void main(String[] args) {
//创建服务,创建线程池
//newFixedThreadPool 参数为:线程池大小
ExecutorService service=Executors.newFixedThreadPool(10);
//执行
service.execute(new MyThread());
service.execute(new MyThread());
service.execute(new MyThread());
//关闭服务
service.shutdown();
}
}
//通过实现runnable创建线程
class MyThread implements Runnable{
@Override
public void run() {
System.out.println("子线程");
}
}
效果: