线程的4种实现方式

最新推荐文章于 2024-08-29 23:20:33 发布

程农

最新推荐文章于 2024-08-29 23:20:33 发布

阅读量1k

点赞数

分类专栏：并发编程文章标签： java jvm spring

本文链接：https://blog.csdn.net/weixin_45035342/article/details/126349946

版权

并发编程专栏收录该内容

5 篇文章 0 订阅

订阅专栏

一，继承Thread：

自定义一个类，继承java.lang包下的Thread类
重写run方法
将要在线程中执行的代码编写在run方法中
创建上面自定义类的对象
调用start方法启动线程。

public class MyThread extends Thread{
	@Override
	public void run() {
		super.run();
		System.out.println("实现run方法");
	}
	public static void main(String[] args) {
		MyThread th = new MyThread();
		th.start();
	}
}

总结：

这种方式的优点是在run方法内可以使用this获取当前线程，无须使用Thread.currentThread方法；
缺点是因为Java的类只能继承一个类，所以继承Thread类之后，就不能继承其他类了，
而且因为任务和代码没有分离，如果多个线程执行相同的任务时，需要多份任务代码。

二、实现Runnable接口

自定义一个类，实现java.lang包下的Runnable接口
重写run方法
将要在线程中执行的代码编写在run方法中
创建上面自定义类的对象
创建Thread对象并将上面自定义类的对象作为参数传递给Thread的构造方法中。
调用start方法启动线程

public class MyRunnable implements Runnable{
	@Override
	public void run() {
		System.out.println("调用runnable类接口");
	}
	public static void main(String[] args) {
		MyRunnable runnable = new MyRunnable();
		//创建线程
		Thread th = new Thread(runnable);
		th.start();
	}
}

总结：

这种方式的优点是因为Java的类可以实现多个接口，所以这个类就可以继承自己需要的类了，
而且任务和代码分离，如果多个线程执行相同的任务时，可以公用同一个任务的代码，
如果需要对它们区分，可以添加参数进行区分。

三、实现Callable接口

自定义一个类实现java.util.concurrent包下的Callable接口。
重写Call方法。
将要在线程中执行的代码编写在call方法中。
创建ExecutorSercice线程池。
将自定义的对象放入线程池中。
获取线程返回结果。
关闭线程，不在接受新的线程，未执行的完的线程不会被关闭。

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
 
public class test04 {
	public static void main(String[] args) throws InterruptedException, ExecutionException {
		ExecutorService newFixedThreadPool = Executors.newFixedThreadPool(1);
		//通过匿名内部类的方式创建Callable类型对象
		Callable<String>callable = new Callable<String>() {
 
			@Override
			public String call() throws Exception {
				System.out.println(Thread.currentThread().getName());
				Thread.sleep(1000);
				return "测试Callable的返回值";
			}
		};
		Future<String> future = newFixedThreadPool.submit(callable);
		//获取线程的返回结果，主线程在执行
		String str = future.get();
		System.out.println(str);
		newFixedThreadPool.shutdown();//关闭线程池
	}
}

四、创建Executor的工具类创建线程池，通过线程池获取线程

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
 
public class test05 {
		public static void main(String[] args) {
			//创建固定线程池对象
			ExecutorService threadPool = Executors.newFixedThreadPool(2);
			Runnable r = new Runnable() {
				@Override
				public void run() {
			System.out.println(Thread.currentThread().getName());
			//如果有一个线程，一个执行完毕后再执行另一个
			//如果有多个线程，可以同时执行多个任务
				}
			};
			threadPool.execute(r);
			threadPool.shutdown();
		}
}