01_创建线程的方式

Ayui.

已于 2023-09-05 09:29:03 修改

阅读量33

点赞数

分类专栏： 01_frame_basic 文章标签： java jvm 开发语言

于 2023-07-25 10:10:22 首次发布

本文链接：https://blog.csdn.net/m0_61569709/article/details/131911507

版权

01_frame_basic 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

1 方式1：继承Thread类重写run方法

1 创建类继承Thread
2 重写run方法 封装线程任务
3 创建此Thread子类对象
4 调用start方法 启动线程

public class Demo01 {
	public static void main(String[] args) {
		
		//方式：继承thread 重写run方法
		// 3 创建此Thread子类对象
		MyThread mt1=new MyThread(); mt1.setName("继承Thread重写run方法：：：");
		// 4 调用start方法 启动线程
		mt1.start();
		
		//main线程代码
		for (int i = 0; i < 50; i++) {
			try {Thread.sleep(50);} catch (Exception e) {}
			System.out.println(Thread.currentThread().getName()+"::::"+i+"::::"+Math.random());
		}
	}
}
// 1 创建类继承Thread
class MyThread extends Thread{
	// 2 重写run方法 封装线程任务
	public void run(){
		for (int i = 0; i < 50; i++) {
			try {Thread.sleep(50);} catch (Exception e) {}
			System.out.println(Thread.currentThread().getName()+"::::"+i+"::::"+(char)(Math.random()*10+'0'));
		}
	}
}

2 方式2：实现Runnable接口实现run方法

//1 创建Runnable接口的实现类
//2 实现run方法
//3 创建实现类实例
//4 创建线程对象 并通过构造方法关联实现类对象
//5启动线程

public class Demo01 {
	public static void main(String[] args) {
		//方式2：实现Runnable接口 实现run方法
		//3 创建实现类实例
		MyImp imp1=new MyImp();
		//4 创建线程对象 并通过构造方法关联实现类对象
		Thread t2=new Thread(imp1);t2.setName("实现Runnable接口 实现run方法！！！！！");
		//5启动线程
		t2.start();
		
		//main线程代码
		for (int i = 0; i < 50; i++) {
			try {Thread.sleep(50);} catch (Exception e) {}
			System.out.println(Thread.currentThread().getName()+"::::"+i+"::::"+Math.random());
		}
	}
}
//1 创建Runnable接口的实现类
class MyImp implements Runnable{
	//2 实现run方法
	public void run(){
		for (int i = 0; i < 50; i++) {
			try {Thread.sleep(50);} catch (Exception e) {}
			System.out.println(Thread.currentThread().getName()+"::::"+i+"::::"+(char)(Math.random()*26+'a'));
		}
	}
}

3 方式3：实现Callable接口实现call方法

1:创建Callable接口的实现类
2：实现call方法：可以抛出异常 并指定返回值
3：创建实现类对象
4： 创建FutureTask对象  并通过构造方法关联实现类对象
5： 创建线程对象 并通过构造方法关联FutureTask对象
6：启动线程
7：通过FutureTask对象的get方法获取返回值

public class Demo01 {
	public static void main(String[] args) throws Exception{
		
		
		//方式3：实现Callable接口 实现call方法
		//3 创建实现类实例
		MyCall call1=new MyCall();
		//4 创建FutureTask对象  并通过构造方法关联实现类对象
		FutureTask<Integer> task=new FutureTask<Integer>(call1);
		//5 创建线程对象 并通过构造方法关联FutureTask对象
		Thread t3=new Thread(task);t3.setName("实现Runnable接口 实现run方法！！！！！");
		//6 启动线程
		t3.start();
		//通过FutureTask对象的get方法 获取返回值
		System.out.println("线程的返回值是：：：：：：：：：sum="+task.get());

		
		//main线程代码
		for (int i = 0; i < 50; i++) {
			try {Thread.sleep(50);} catch (Exception e) {}
			System.out.println(Thread.currentThread().getName()+"::::"+i+"::::"+Math.random());
		}
	}
}
//1 创建Callable接口的实现类：泛型指定返回值类型
class MyCall implements Callable<Integer>{
    //2 实现call方法 可以抛出异常 并指定返回值
	public Integer call() throws Exception {
		int sum=0;
		for (int i = 0; i < 50; i++) {
			Thread.sleep(50);
			int score=(int)(Math.random()*100);
			sum+=score;
			System.out.println(Thread.currentThread().getName()+"::::"+i+"::::"+score);
		}
		return sum;
	}
	
}
//1 创建Runnable接口的实现类
class MyImp implements Runnable{
	//2 实现run方法
	public void run(){
		for (int i = 0; i < 50; i++) {
			try {Thread.sleep(50);} catch (Exception e) {}
			System.out.println(Thread.currentThread().getName()+"::::"+i+"::::"+(char)(Math.random()*26+'a'));
		}
	}
}
// 1 创建类继承Thread
class MyThread extends Thread{
	// 2 重写run方法 封装线程任务
	public void run(){
		for (int i = 0; i < 50; i++) {
			try {Thread.sleep(50);} catch (Exception e) {}
			System.out.println(Thread.currentThread().getName()+"::::"+i+"::::"+(char)(Math.random()*10+'0'));
		}
	}
}

4 方式4：通过线程池对象

对指定个数个线程对象的创建，维护，分配，销毁等工作进行管理的对象：：池对象
作用：实现对象的复用：避免频繁的创建和销毁

1 创建Callable或者Runnable的实现类
2 重写run/call方法 封装线程任务
3 创建ExecutorService线程池对象 并指池类型
4 通过池对象的submit方法 来提交线程任务：：如果提交的线程任务是Callable 开头通过Future来接受线程的返回值
5 调用shutdown方法：关闭池对象

public class Demo01 {
	public static void main(String[] args) throws Exception{
	
		
		//方式4：通过线程池ExecutorService实现多线程
		//1 创建Callable或者Runnable的实现类
		MyImp imp1=new MyImp();
		MyCall call1=new MyCall();
		//2 重写run/call方法 封装线程任务
		//3 创建ExecutorService线程池对象
		ExecutorService service=Executors.newFixedThreadPool(4);//指定初始线程个数
		//4 通过submit提交线程任务给线程池::如果是Callable可以通过Future来接受线程的返回值
		service.submit(imp1);
		service.submit(new Runnable() {
			public void run() {
				for (int i = 0; i < 50; i++) {
					try {Thread.sleep(50);} catch (Exception e) {}
					System.out.println(Thread.currentThread().getName()+"::::"+i+":::::@@@@@@@@@@@@@@@@"+(char)(Math.random()*26+'A'));
				}
			}
		});
		Future<Integer> future1=service.submit(call1);
		Future<Double> future2=service.submit(new Callable<Double>() {
			public Double call() throws Exception {
				double sum=0;
				for (int i = 0; i < 50; i++) {
					Thread.sleep(50);double score=(int)(Math.random()*100);sum+=score;
					System.out.println(Thread.currentThread().getName()+"::::"+i+":::::###########################"+score);
				}
				return sum;
			}
		});
		//获取返回值值
		System.out.println("线程3的返回值：：："+future1.get());
		System.out.println("线程4的返回值：：："+future2.get());
		//5 关闭线程池
		service.shutdown();
		
	
	}
}
//1 创建Callable接口的实现类：泛型指定返回值类型
class MyCall implements Callable<Integer>{
    //2 实现call方法 可以抛出异常 并指定返回值
	public Integer call() throws Exception {
		int sum=0;
		for (int i = 0; i < 50; i++) {
			Thread.sleep(50);
			int score=(int)(Math.random()*100);
			sum+=score;
			System.out.println(Thread.currentThread().getName()+"::::"+i+"::::"+score);
		}
		return sum;
	}
	
}
//1 创建Runnable接口的实现类
class MyImp implements Runnable{
	//2 实现run方法
	public void run(){
		for (int i = 0; i < 50; i++) {
			try {Thread.sleep(50);} catch (Exception e) {}
			System.out.println(Thread.currentThread().getName()+"::::"+i+"::::!!!!!"+(char)(Math.random()*26+'a'));
		}
	}
}
// 1 创建类继承Thread
class MyThread extends Thread{
	// 2 重写run方法 封装线程任务
	public void run(){
		for (int i = 0; i < 50; i++) {
			try {Thread.sleep(50);} catch (Exception e) {}
			System.out.println(Thread.currentThread().getName()+"::::"+i+"::::<<<<<<<<<"+(char)(Math.random()*10+'0'));
		}
	}
}