Coin163

首页 > java多线程(一)线程状态与创建线程

java多线程(一)线程状态与创建线程

2021腾讯云限时秒杀,爆款1核2G云服务器298元/3年!(领取2860元代金券),
地址https://cloud.tencent.com/act/cps/redirect?redirect=1062

2021阿里云最低价产品入口+领取代金券(老用户3折起),
入口地址https://www.aliyun.com/minisite/goods

相关推荐:java多线程

一、多线程 1、操作系统有两个容易混淆的概念,进程和线程。 进程:一个计算机程序的运行实例,包含了需要执行的指令;有自己的独立地址空间,包含程序内容和数据;不同进程的地址空间是互相隔离的;进程拥有各种资源和状态信息,包括打开的文件、子进程和信

一、几个基本概念的区分

1.进程与程序的区分

程序 进程 包含代码部分、数据部分 包含代码部分、数据部分、进程控制块 顺序执行 并发执行 独占资源 共享资源 同步的 异步的 静态的 动态的 (本质区别)

2.线程与进程的关系

相同:线程是轻量级的进程,一个进程可以包含一至多个线程

区别:

进程既是资源分配的单位有是独立运行的单位,线程只是资源分配的单位,只是运行的单位

建线程比进程开销小

3.线程的状态图



二、线程创建的两种方式:

1.直接从Thread类继承 2.实现Runnable接口创建一个任务类,然后 Thread t = new Thread(Runnable r)  即可创建一个线程

/*
 *1.实现Runnable接口重写run()方法来定义任务 
 */
public class LiftOff implements Runnable {
	
	protected int countDown = 10;
	private static int taskCount = 0;
	private final int id = taskCount++;			//用来区分多个任务的实例
	
	public LiftOff(){}
	
	public LiftOff(int countDown){
		this.countDown = countDown;
	}
	
	public String status(){
		return "#" + id + "(" + (countDown > 0 ? countDown : "Liftoff!") + "),   ";
	}

	@Override
	public void run() {
		while(countDown-- > 0){
			System.out.println(status());
			Thread.yield();			//让步,仅仅是暗示CPU,没有任何机制保证它将会被执行
			/*try {
				Thread.sleep(300);			//睡眠,线程停止多少毫秒
			} catch (InterruptedException e) {
				e.printStackTrace();
			}*/
		}
	}
	
	public static void main(String[] args) {
		Thread t1 = new Thread(new  LiftOff(10));
		Thread t2 = new Thread(new  LiftOff(10));
		t1.setPriority(Thread.MAX_PRIORITY);		//设置优先级,优先级高的相对获得的时间片多一点,并不保证
	    t1.start();
	    t2.start();
	    System.out.println(t1.getPriority());
	    System.out.println(t2.getPriority());
	    System.out.println("----------------------");
	}
	
}

三、java.util.concurrent中常用类与接口

相关推荐:java多线程--中断线程

2. 终止线程的方式 Thread中的stop()和suspend()方法,由于固有的不安全性,已经建议不再使用! 下面,我先分别讨论线程在“阻塞状态”和“运行状态”的终止方式,然后再总结出一个通用的方式。 2.1 终止处于“阻塞状态”的线程 通常,我们通过“中断”方式终

Callable:可以在任务完成时返回一个值 

Runnable:是执行工作的独立任务,但是它不返回任何值

Executor:具体Runnerable任务的执行者,中介对象

ExecutorService:一个线程池管理者,其实现类有多种。我们能把Runnable,Callable提交到池中让其调度(具有服务生命周期的Executor,例如关闭)

Executors:创建并返回ExecutorService等

Future:返回任务的上下文

1.下面介绍Executors的常用方法及区别

public class CachedThreadPool {
	public static void main(String[] args) {
		//ExecutorService exec = Executors.newFixedThreadPool(5);   //创建一个可重用固定大小线程集合的线程池(可一次性预先执行代价高昂的线程分配)
		ExecutorService exec = Executors.newCachedThreadPool();		//创建一个可根据需要创建新线程的线程池(无界)
		for(int i = 0; i < 5; i++){
			exec.execute(new LiftOff());
		}
		exec.shutdown();
	}
}

/*
 *就像是线程数量为1的FixedThreadPool,适用于在一个线程中连续运行的事物(原子性)
 *如果向它提交多个任务,那么这些任务将排队 
 */
public class SingleThreadExecutor {
	public static void main(String[] args) {
		ExecutorService exec = Executors.newSingleThreadExecutor();
		for(int i= 0; i<5; i++)
			exec.execute(new LiftOff());
		exec.shutdown();
	}
}

2.Runnable:是执行工作的独立任务,但是它不返回任何值,Callable:可以在任务完成时返回一个值 

ExecutorService.submit()方法会返回一个Future对象,Future的相关方法:

idDone():查询Future是否已经完成

cancel(boolean mayInterruptIfRunning)  //试图取消对任务的执行
get():当任务完成时,可以用get()返回结果

class TaskWithResults implements Callable<String>{
	public int id;
	public TaskWithResults(int id){
		this.id = id;
	}

	@Override
	public String call() throws Exception {
		return "result of TaskWithResults: " + id;
	}
}

public class CallableDemo {
	public static void main(String[] args) {
		ExecutorService exec = Executors.newCachedThreadPool();
		List<Future<String>> results = new ArrayList<Future<String>>();
		for(int i = 0; i < 5; i++){
			results.add(exec.submit(new TaskWithResults(i)));
		}
		for (Iterator<Future<String>> iterator = results.iterator(); iterator.hasNext();) {
			Future<String> future = (Future<String>) iterator.next();
			try {
				System.out.println(future.get());
			} catch (InterruptedException | ExecutionException e) {
				e.printStackTrace();
			}finally{
				exec.shutdown();	//启动一次顺序关闭,执行以前提交的任务,但不接受新任务
			}
		}
	}
}


原文

一、几个基本概念的区分 1.进程与程序的区分 程序 进程 包含代码部分、数据部分 包含代码部分、数据部分、进程控制块 顺序执行 并发执行 独占资源 共享资源 同步的 异步的 静态的 动态的 (本质

------分隔线----------------------------