线程的实现方式

最新推荐文章于 2024-10-01 18:51:18 发布

猿究◎小飞

最新推荐文章于 2024-10-01 18:51:18 发布

阅读量92

点赞数 2

分类专栏： JavaSE部分文章标签： java 算法开发语言

本文链接：https://blog.csdn.net/qq_62283164/article/details/131772016

版权

JavaSE部分专栏收录该内容

14 篇文章 0 订阅

订阅专栏

文章介绍了Java中实现多线程的四种方式：1)继承Thread类创建子线程；2)实现Runnable接口并通过Thread启动；3)实现Callable接口，允许线程返回结果和抛出异常；4)使用ExecutorService线程池进行任务调度。每种方式都有其适用场景和特点。

摘要由CSDN通过智能技术生成

方式一：继承 java.lang.Thread 类（线程子类）

public class SubThread extends Thread {
       public void run() {
           for (int i = 0; i < 10000; i++) {
               System.out.println("子线程" + i + " ");
           }
       }
}

// 主线程main
public class MultiThread {
       public static void main(String[] args) {
            //创建并启动子线程
           SubThread thd = new SubThread();
           thd.start();
           
           //主线程继续同时向下执行
           for (int i = 0; i < 10000; i++) {
               System.out.println("主线程" + i + " ");
           }
       }
}

方式二：实现 java.lang.Runnable 接口（线程执行类）

public class SubThread implements Runnable {
    public void run() {
        for (int i = 0; i < 10000; i++) {
            System.out.println("子线程" + i + " ");
        }
    }
}

// 主线程 main
public class MultiThread {
    public static void main(String[] args) {
        //创建并启动子线程
        Thread t = new Thread(new SubThread());
        t.start(); 

        //主线程继续同时向下执行
        for (int i = 0; i < 10000; i++) {
            System.out.println("主线程" + i + " ");
        }
    }
}

方式三：实现 java.util.concurrent.Callable 接口，允许子线程返回结果、抛出异常

package com.apesource.yuan6;
//线程创建方式3：实现Callable接口
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class test4 {
	public static void main(String[] args) throws InterruptedException, ExecutionException {
		//Callable接口实现类：不同数据范围的计算任务
		SumCalcTask task1=new SumCalcTask(0, 400);
		SumCalcTask task2=new SumCalcTask(401, 700);
		SumCalcTask task3=new SumCalcTask(701, 1000);
		//Callable-->Future Task（Runnable）接口实现类
		FutureTask<Integer> futuretask1=new FutureTask<Integer>(task1);
		FutureTask<Integer> futuretask2=new FutureTask<Integer>(task2);
		FutureTask<Integer> futuretask3=new FutureTask<Integer>(task3);
		
		//创建并启动线程
		Thread thread1=new Thread(futuretask1);
		Thread thread2=new Thread(futuretask2);
		Thread thread3=new Thread(futuretask3);
		//线程启动
		//futuretask1.run();=>callable.call=>结果-->outcome
		thread1.start();
		thread2.start();
		thread3.start();
		//线程执行结束，分别获取各自线程的返回结果
		System.out.println("开始分别获取......");
		Integer ret1=futuretask1.get();
		Integer ret2=futuretask2.get();
		Integer ret3=futuretask3.get();
		//汇总
		System.out.println("汇总各自计算结果");
		Integer result=ret1+ret2+ret3;
		System.out.println(result);
	}
}
class SumCalcTask implements Callable<Integer>{
	private int begin,end;
	public SumCalcTask(int begin,int end) {
		this.begin=begin;
		this.end=end;
	}
	@Override
	public Integer call() throws Exception {
		int ret=0;
		for(int i=begin;i<=end;i++) {
			ret+=i;
		}
		return ret;
	}
	
	
}

方式四：线程池

线程池，按照配置参数（核心线程数、最大线程数等）创建并管理若干线程对象。程序中如果需要使用线程，将一个执行任务传给线程池，线程池就会使用一个空闲状态的线程来执行这个任务。执行结束以后，该线程并不会死亡，而是再次返回线程池中成为空闲状态，等待执行下一个任务。使用线程池可以很好地提高性能。

package com.apesource.yuan6;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
//线程创建方式4：通过线程池创建
public class test5 {
	public static void main(String[] args) {
		//固定数量的线程池
		ExecutorService executorService=Executors.newFixedThreadPool(10);
		//不确定数量的线程请求
		while(true){
			//向线程池提交一个执行任务（Runnable接口实现类对象）
			//线程池分配一个“空闲线程”执行该任务
			//如果没有空闲线程，则该任务进入“等待队列（工作队列）”
		executorService.execute(new Runnable() {
			@Override
			public void run() {
				System.out.println(Thread.currentThread().getName());
				try {
					Thread.sleep(1000);//当前线程休眠1000毫秒
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		});
		}
	}
}