文档章节

java 线程返回值,优先级,后台线程 示例代码

猪刚烈
 猪刚烈
发布于 2014/08/16 09:35
字数 1533
阅读 7
收藏 0

ava 线程返回值,休眠,优先级,后台线程  示例代码

package org.rui.thread.basic;

import java.util.ArrayList;
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;
/**
 * 从任务中产生返回值 Callable接口应用
 * 也可以用isDone()来查询Future是否已经完成
 * 也可以直接get()进行检查 
 * 
 * @author lenovo
 *
 */

class TaskWithResult implements Callable<String>
{
	private int id;	
	public TaskWithResult(int id){this.id=id;}
	
	@Override
	public String call() throws Exception {
		return "result of TaskWotjResult"+id;
	}
}


public class CallableDemo  {
	/////////////////
	public static void main(String[] args) {
		ExecutorService exec=Executors.newCachedThreadPool();
		ArrayList<Future<String>> result=new ArrayList<Future<String>>();
		for(int i=0;i<10;i++)
		{
			result.add(exec.submit(new TaskWithResult(i)));
		}
		
		for(Future<String> fs:result)
			try {
				System.out.println(fs.get());
			} catch (InterruptedException e) {
				e.printStackTrace();
				return;
			} catch (ExecutionException e) {
				e.printStackTrace();
			}finally
			{
				exec.shutdown();
			}
		
	}

}

/**
 * output:
result of TaskWotjResult0
result of TaskWotjResult1
result of TaskWotjResult2
result of TaskWotjResult3
result of TaskWotjResult4
result of TaskWotjResult5
result of TaskWotjResult6
result of TaskWotjResult7
result of TaskWotjResult8
result of TaskWotjResult9
 */

package org.rui.thread.basic;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
 * 线程优先级
 * @author lenovo
 *
 */
public class SimpleProorities implements Runnable{
  
	private int countDown=5;
	private volatile double d; //No optimization
	private int priority;
	
	public SimpleProorities(int priority)
	{
		this.priority=priority;
	}
	
	public String toString()
	{
		return Thread.currentThread()+" : "+countDown;
	}
	 
	@Override
	public void run() {
		Thread.currentThread().setPriority(priority);//开头设置优先级
		while(true)
		{
			for(int i=1;i<100000;i++)
			{
				//比任何其他值都更接近 pi(即圆的周长与直径之比)的 double 值。
				//任何其他值都更接近 e(即自然对数的底数)的 double 值。
				d+=(Math.PI+Math.E)/(double)i;
				if(i%1000==0)
					Thread.yield();
			}
			
			System.out.println(this);
			if(--countDown==0)return;
		}
		
	}
	
	public static void main(String[] args) {
		ExecutorService exec=Executors.newCachedThreadPool();
		for(int i=0;i<5;i++)
			exec.execute(new SimpleProorities(Thread.MIN_PRIORITY));
			exec.execute(new SimpleProorities(Thread.MAX_PRIORITY));//优先级高
		
		exec.shutdown();
		
	}

}

package org.rui.thread.basic;

import java.util.concurrent.TimeUnit;
/**
 * 后台线程
 * 是指在程序运行的时候在后台提供一种通用服务的线程
 * @author lenovo
 *
 */
public class SimpleDeamons  implements Runnable{

	@Override
	public void run() {
		try {
				while(true)
				{
					
						TimeUnit.MILLISECONDS.sleep(100);
						System.out.println(Thread.currentThread()+" >>> "+this);
					
				}
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}

	public static void main(String[] args) {
		for(int i=0;i<10;i++)
		{
			Thread daemon=new Thread(new SimpleDeamons());
			daemon.setDaemon(true);//设为后台 线程
			daemon.start();
		}
		System.out.println("all daemons started------");
		try {
			//试试调整休眠时间 以观察这个行为
			TimeUnit.MILLISECONDS.sleep(175);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}
/**
 * output:
 all daemons started------
Thread[Thread-8,5,main] >>> org.rui.thread.basic.SimpleDeamons@1e4f7c2
Thread[Thread-9,5,main] >>> org.rui.thread.basic.SimpleDeamons@10dc6b5
Thread[Thread-4,5,main] >>> org.rui.thread.basic.SimpleDeamons@1d0fafc
Thread[Thread-6,5,main] >>> org.rui.thread.basic.SimpleDeamons@c9d92c
Thread[Thread-0,5,main] >>> org.rui.thread.basic.SimpleDeamons@145f0e3
Thread[Thread-2,5,main] >>> org.rui.thread.basic.SimpleDeamons@1e4f7c2
Thread[Thread-5,5,main] >>> org.rui.thread.basic.SimpleDeamons@b8f8eb
Thread[Thread-1,5,main] >>> org.rui.thread.basic.SimpleDeamons@d0af9b
Thread[Thread-7,5,main] >>> org.rui.thread.basic.SimpleDeamons@f47396
Thread[Thread-3,5,main] >>> org.rui.thread.basic.SimpleDeamons@170bea5

 */

package org.rui.thread.basic;

import java.util.concurrent.ThreadFactory;

/**
 *通过编写定制的threadFactory可以定制由Executor创建的线程的属性 (后台,优先级,名称)
 * @author lenovo
 *
 */
public class DaemonThreadFactory implements ThreadFactory{

	@Override
	public Thread newThread(Runnable r) {
		Thread thread=new Thread(r);
		thread.setDaemon(true);
		return thread;
	}

}

package org.rui.thread.basic;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

/**
 * 这与普通的ThreadFactory的唯一差异就是它将后台状态全部设置为了true
 * 你现在可以用一个新的DaemonThreadFactory作为参数传递给executory.newCachedThreadPool()
 * @author lenovo
 *
 */
public class DeamonFromFactory implements Runnable{

	@Override
	public void run() {
		try {
			while(true)
			{
				TimeUnit.MILLISECONDS.sleep(100);
				System.out.println(Thread.currentThread()+" >> "+this);
			}
		} catch (Exception e) {
		
		}
		
	}
	/////
	public static void main(String[] args) throws InterruptedException {
		//每一个ExecutorService创建方法都被重载为接受一个threadfactory对象
		//而这个对象将被用来创建新的线程
		ExecutorService exec=Executors.newCachedThreadPool(new DaemonThreadFactory());
		for(int i=0;i<10;i++)
		{
			exec.execute(new DeamonFromFactory());
		}
		
		System.out.println("all daemons started");
		TimeUnit.MILLISECONDS.sleep(500);
	}

}

/**output:
 all daemons started
Thread[Thread-0,5,main] >> org.rui.thread.basic.DeamonFromFactory@8ab708
Thread[Thread-3,5,main] >> org.rui.thread.basic.DeamonFromFactory@9934d4
Thread[Thread-5,5,main] >> org.rui.thread.basic.DeamonFromFactory@f6ac0b
Thread[Thread-4,5,main] >> org.rui.thread.basic.DeamonFromFactory@1c0f2e5
Thread[Thread-2,5,main] >> org.rui.thread.basic.DeamonFromFactory@13c7378
Thread[Thread-1,5,main] >> org.rui.thread.basic.DeamonFromFactory@54c4ad
Thread[Thread-6,5,main] >> org.rui.thread.basic.DeamonFromFactory@5b8827
Thread[Thread-7,5,main] >> org.rui.thread.basic.DeamonFromFactory@d09ad3
Thread[Thread-8,5,main] >> org.rui.thread.basic.DeamonFromFactory@147c1db
Thread[Thread-9,5,main] >> org.rui.thread.basic.DeamonFromFactory@82d37
Thread[Thread-0,5,main] >> org.rui.thread.basic.DeamonFromFactory@8ab708
Thread[Thread-5,5,main] >> org.rui.thread.basic.DeamonFromFactory@f6ac0b
Thread[Thread-3,5,main] >> org.rui.thread.basic.DeamonFromFactory@9934d4
Thread[Thread-1,5,main] >> org.rui.thread.basic.DeamonFromFactory@54c4ad
Thread[Thread-4,5,main] >> org.rui.thread.basic.DeamonFromFactory@1c0f2e5
Thread[Thread-2,5,main] >> org.rui.thread.basic.DeamonFromFactory@13c7378
Thread[Thread-6,5,main] >> org.rui.thread.basic.DeamonFromFactory@5b8827
Thread[Thread-8,5,main] >> org.rui.thread.basic.DeamonFromFactory@147c1db
Thread[Thread-7,5,main] >> org.rui.thread.basic.DeamonFromFactory@d09ad3
Thread[Thread-9,5,main] >> org.rui.thread.basic.DeamonFromFactory@82d37
Thread[Thread-5,5,main] >> org.rui.thread.basic.DeamonFromFactory@f6ac0b
Thread[Thread-1,5,main] >> org.rui.thread.basic.DeamonFromFactory@54c4ad
Thread[Thread-0,5,main] >> org.rui.thread.basic.DeamonFromFactory@8ab708
Thread[Thread-3,5,main] >> org.rui.thread.basic.DeamonFromFactory@9934d4
Thread[Thread-7,5,main] >> org.rui.thread.basic.DeamonFromFactory@d09ad3
Thread[Thread-4,5,main] >> org.rui.thread.basic.DeamonFromFactory@1c0f2e5
Thread[Thread-2,5,main] >> org.rui.thread.basic.DeamonFromFactory@13c7378
Thread[Thread-6,5,main] >> org.rui.thread.basic.DeamonFromFactory@5b8827
Thread[Thread-8,5,main] >> org.rui.thread.basic.DeamonFromFactory@147c1db
Thread[Thread-9,5,main] >> org.rui.thread.basic.DeamonFromFactory@82d37
Thread[Thread-1,5,main] >> org.rui.thread.basic.DeamonFromFactory@54c4ad
Thread[Thread-5,5,main] >> org.rui.thread.basic.DeamonFromFactory@f6ac0b
Thread[Thread-3,5,main] >> org.rui.thread.basic.DeamonFromFactory@9934d4
Thread[Thread-0,5,main] >> org.rui.thread.basic.DeamonFromFactory@8ab708
Thread[Thread-8,5,main] >> org.rui.thread.basic.DeamonFromFactory@147c1db
Thread[Thread-6,5,main] >> org.rui.thread.basic.DeamonFromFactory@5b8827
Thread[Thread-2,5,main] >> org.rui.thread.basic.DeamonFromFactory@13c7378
Thread[Thread-4,5,main] >> org.rui.thread.basic.DeamonFromFactory@1c0f2e5
Thread[Thread-7,5,main] >> org.rui.thread.basic.DeamonFromFactory@d09ad3
Thread[Thread-9,5,main] >> org.rui.thread.basic.DeamonFromFactory@82d37
Thread[Thread-0,5,main] >> org.rui.thread.basic.DeamonFromFactory@8ab708
Thread[Thread-3,5,main] >> org.rui.thread.basic.DeamonFromFactory@9934d4
Thread[Thread-1,5,main] >> org.rui.thread.basic.DeamonFromFactory@54c4ad
Thread[Thread-5,5,main] >> org.rui.thread.basic.DeamonFromFactory@f6ac0b
Thread[Thread-8,5,main] >> org.rui.thread.basic.DeamonFromFactory@147c1db
Thread[Thread-6,5,main] >> org.rui.thread.basic.DeamonFromFactory@5b8827
Thread[Thread-2,5,main] >> org.rui.thread.basic.DeamonFromFactory@13c7378
Thread[Thread-4,5,main] >> org.rui.thread.basic.DeamonFromFactory@1c0f2e5
Thread[Thread-7,5,main] >> org.rui.thread.basic.DeamonFromFactory@d09ad3

 */

package org.rui.thread.basic;

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
/**
 * 每个静态的executorService创建方法都被重载为接受一个threadfactory对象,
 * 而这个对象将被用来创建新的线程
 * @author lenovo
 *
 */
public class DaemonThreadPoolExecutor extends ThreadPoolExecutor {

	public DaemonThreadPoolExecutor() {
		super(0,Integer.MAX_VALUE,60L,TimeUnit.SECONDS,
				new SynchronousQueue<Runnable>(),
				new DaemonThreadFactory());
		
	}

}

package org.rui.thread.basic;

import java.util.concurrent.TimeUnit;

/**
 * 可以通过调用isDaemon方法来确定线程是否是一个后台线程。如果是一个后台线程,
 * 那么创建的任何线程将被自动设置成后台线程,如下例所示
 * @author lenovo
 *
 */
  class Daemon implements Runnable {

	private Thread[] t=new Thread[10];
	
	@Override
	public void run() {
		for(int i=0;i<t.length;i++)
		{
			t[i]=new Thread(new DaemonSpawn());
			t[i].start();
			System.out.println("daemonSpawn "+i+" started, ");
		}
		for(int i=0;i<t.length;i++)
		{
			System.out.println("t["+i+"].isDaemon()="+t[i].isDaemon()+" ,");
		}
		/**
		 * 对线程调度器  java线程机制的一部分,可以将cpu从一个线程转移给另一个线程 的一种建议
		 * 它在声明: 我已经执行完生命周期中最重要的部分了,此刻正是切换给其他任务执行一段时间的大好时机  
		 * 完全是先择性的,
		 * 
		 */
		while(true)
			Thread.yield();//把控制权交给其它线程
		
	}

}

	class DaemonSpawn implements Runnable
	{
		@Override
		public void run() 
		{
			while(true)
				Thread.yield();
		}
	 }
	////////////////////////////////////
	public class Daemons 
	{
		public static void main(String[] args) throws InterruptedException 
		{
			Thread d=new Thread(new Daemon());
			d.setDaemon(true);
			d.start();
			System.out.println("d.isDaemon()="+d.isDaemon()+"  , ");
			TimeUnit.MILLISECONDS.sleep(1);
		}
		
	}
/**
 d.isDaemon()=true  , 
daemonSpawn 0 started, 
daemonSpawn 1 started, 
daemonSpawn 2 started, 
daemonSpawn 3 started, 
daemonSpawn 4 started, 
daemonSpawn 5 started, 
daemonSpawn 6 started, 
daemonSpawn 7 started, 
daemonSpawn 8 started, 
daemonSpawn 9 started, 
t[0].isDaemon()=true ,
t[1].isDaemon()=true ,
t[2].isDaemon()=true ,
t[3].isDaemon()=true ,
t[4].isDaemon()=true ,
t[5].isDaemon()=true ,
t[6].isDaemon()=true ,
t[7].isDaemon()=true ,
t[8].isDaemon()=true ,
t[9].isDaemon()=true ,
 */

package org.rui.thread.basic;

import java.util.concurrent.TimeUnit;

/**
 * 你就该意识到后台进程在不执行finally子句的情况下就会终止其run()方法
 * @author lenovo
 *
 */

class ADeamon implements Runnable{

	@Override
	public void run() {
		try {
			System.out.println("starting adaemon");
			TimeUnit.MILLISECONDS.sleep(1);
		} catch (InterruptedException e) {
			System.out.println("正在退出 经过 InterruptedException");
		}finally
		{
			//这应该 run?
			System.out.println("this should always run?");
		}
		
	}
	
 }
public class DaemonDontRunFinally  {
	//你将看到finally子句不会执行  如果注释t.setDaemon(true); 就会看到
  public static void main(String[] args) {
	Thread t=new Thread(new ADeamon());
	t.setDaemon(true);
	t.start();
	//一旦main退出 jvm就会立即关闭后台线程
}
}
/**output:
 starting adaemon
 */


本文转载自:http://blog.csdn.net/liangrui1988/article/details/35647441

猪刚烈
粉丝 22
博文 708
码字总数 110
作品 1
海淀
程序员
私信 提问
Java多线程可以分组,还能这样玩!

前面的文章,栈长和大家分享过多线程创建的3种方式《实现 Java 多线程的 3 种方式》。 但如果线程很多的情况下,你知道如何对它们进行分组吗? 和 Dubbo 的服务分组一样,Java 可以对相同性质...

Java技术栈
2018/11/09
49
0
进一步理解Java中的线程(下)

要想真正的理解Java并发编程,线程是无论如何都必须要彻底理解的一个重要概念。那么,在开始深入介绍之前,我们先来深入的学习一下线程。前面一个章节中已经介绍过线程的一些基本知识,包括线...

HollisChuang's Blog
2018/12/22
0
0
Android开发高手课之卡顿优化

造成卡顿的原因最后都会反映到CPU时间上,可以把CPU时间分为两种:系统时间和用户时间。 用户时间:执行用户态应用程序代码所消耗的时间 系统时间:执行内核态系统调用所消耗的时间,包括I/O...

小菜鸟程序媛
03/12
0
0
从Java到JVM到OS线程的优先级

前言 Java 的线程的调度机制由 JVM 实现,假如有若干条线程,你想让某些线程拥有更长的执行时间,或某些线程分配少点执行时间,这时就涉及“线程优先级”。 优先级别 Java 把线程优先级分成1...

超人汪小建
2018/06/25
0
0
Java 多线程编程总结

一、认识多任务、多进程、单线程、多线程 要认识多线程就要从操作系统的原理说起。 以前古老的DOS操作系统(V 6.22)是单任务的,还没有线程的概念,系统在每次只能做一件事情。比如你在cop...

鉴客
2010/12/16
1K
3

没有更多内容

加载失败,请刷新页面

加载更多

计算机实现原理专题--二进制减法器(二)

在计算机实现原理专题--二进制减法器(一)中说明了基本原理,现准备说明如何来实现。 首先第一步255-b运算相当于对b进行按位取反,因此可将8个非门组成如下图的形式: 由于每次做减法时,我...

FAT_mt
昨天
6
0
好程序员大数据学习路线分享函数+map映射+元祖

好程序员大数据学习路线分享函数+map映射+元祖,大数据各个平台上的语言实现 hadoop 由java实现,2003年至今,三大块:数据处理,数据存储,数据计算 存储: hbase --> 数据成表 处理: hive --> 数...

好程序员官方
昨天
7
0
tabel 中含有复选框的列 数据理解

1、el-ui中实现某一列为复选框 实现多选非常简单: 手动添加一个el-table-column,设type属性为selction即可; 2、@selection-change事件:选项发生勾选状态变化时触发该事件 <el-table @sel...

everthing
昨天
6
0
【技术分享】TestFlight测试的流程文档

上架基本需求资料 1、苹果开发者账号(如还没账号先申请-苹果开发者账号申请教程) 2、开发好的APP 通过本篇教程,可以学习到ios证书申请和打包ipa上传到appstoreconnect.apple.com进行TestF...

qtb999
昨天
10
0
再见 Spring Boot 1.X,Spring Boot 2.X 走向舞台中心

2019年8月6日,Spring 官方在其博客宣布,Spring Boot 1.x 停止维护,Spring Boot 1.x 生命周期正式结束。 其实早在2018年7月30号,Spring 官方就已经在博客进行过预告,Spring Boot 1.X 将维...

Java技术剑
昨天
18
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部