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

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] >>> [email protected]
Thread[Thread-9,5,main] >>> org.ru[email protected]
Thread[Thread-4,5,main] >>> [email protected]
Thread[Thread-6,5,main] >>> [email protected]
Thread[Thread-0,5,main] >>> [email protected]
Thread[Thread-2,5,main] >>> [email protected]
Thread[Thread-5,5,main] >>> [email protected]
Thread[Thread-1,5,main] >>> [email protected]
Thread[Thread-7,5,main] >>> [email protected]
Thread[Thread-3,5,main] >>> [email protected]

 */

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] >> [email protected]
Thread[Thread-3,5,main] >> [email protected]
Thread[Thread-5,5,main] >> [email protected]
Thread[Thread-4,5,main] >> [email protected]
Thread[Thread-2,5,main] >> [email protected]
Thread[Thread-1,5,main] >> [email protected]
Thread[Thread-6,5,main] >> [email protected]
Thread[Thread-7,5,main] >> [email protected]
Thread[Thread-8,5,main] >> [email protected]
Thread[Thread-9,5,main] >> [email protected]
Thread[Thread-0,5,main] >> [email protected]
Thread[Thread-5,5,main] >> [email protected]
Thread[Thread-3,5,main] >> [email protected]
Thread[Thread-1,5,main] >> [email protected]
Thread[Thread-4,5,main] >> [email protected]
Thread[Thread-2,5,main] >> [email protected]
Thread[Thread-6,5,main] >> [email protected]
Thread[Thread-8,5,main] >> [email protected]
Thread[Thread-7,5,main] >> [email protected]
Thread[Thread-9,5,main] >> [email protected]
Thread[Thread-5,5,main] >> [email protected]
Thread[Thread-1,5,main] >> [email protected]
Thread[Thread-0,5,main] >> [email protected]
Thread[Thread-3,5,main] >> [email protected]
Thread[Thread-7,5,main] >> [email protected]
Thread[Thread-4,5,main] >> [email protected]
Thread[Thread-2,5,main] >> [email protected]
Thread[Thread-6,5,main] >> [email protected]
Thread[Thread-8,5,main] >> [email protected]
Thread[Thread-9,5,main] >> [email protected]
Thread[Thread-1,5,main] >> [email protected]
Thread[Thread-5,5,main] >> [email protected]
Thread[Thread-3,5,main] >> [email protected]
Thread[Thread-0,5,main] >> [email protected]
Thread[Thread-8,5,main] >> [email protected]
Thread[Thread-6,5,main] >> [email protected]
Thread[Thread-2,5,main] >> [email protected]
Thread[Thread-4,5,main] >> [email protected]
Thread[Thread-7,5,main] >> [email protected]
Thread[Thread-9,5,main] >> [email protected]
Thread[Thread-0,5,main] >> [email protected]
Thread[Thread-3,5,main] >> [email protected]
Thread[Thread-1,5,main] >> [email protected]
Thread[Thread-5,5,main] >> [email protected]
Thread[Thread-8,5,main] >> [email protected]
Thread[Thread-6,5,main] >> [email protected]
Thread[Thread-2,5,main] >> [email protected]
Thread[Thread-4,5,main] >> [email protected]
Thread[Thread-7,5,main] >> [email protected]

 */

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
 */

java 线程返回值，优先级，后台线程 示例代码,布布扣,bubuko.com

时间： 2024-10-25 18:01:54

java 线程返回值，优先级，后台线程 示例代码的相关文章

java线程返回值讨论

java线程返回值讨论在线程当中,返回值是个很大的问题.比如:在线程执行到某一步的时候要将数据返回,在程序执行完成后要返回值.在java中,线程的返回值可以使用Future<T>来获取,也可以使用其他的手段.以下讨论一些返回值的一些小手段:1.使用静态变量来进行值的返回使用静态变量来进行值的返回是最简单的一种,也是不可取的一种,这种不仅带来线程的安全性,同时内存一直不能释放,直到系统退出才能释放内存,因此会造成内存花费很多,但是真正在使用的很少.2.使用Futuren<T>来获取这

Java多线程和并发（四），线程返回值获取方式和Callable接口

目录 1.主线程等待法 2.使用Thread类的join()阻塞当前线程,等待子线程执行完毕 3.通过Callable接口实现:通过FutureTask Or线程池获取 四.线程返回值获取方式和Callable接口 1.主线程等待法 public class CycleWait implements Runnable{ private String value; @Override public void run() { try { Thread.currentThread().sleep(50

Android平台调用Web Service：线程返回值

接上文 前文中的遗留问题 对于Java多线程的理解,我以前仅仅局限于实现Runnable接口或者继承Thread类,然后重写run()方法,最后start()调用就算完事,但是一旦涉及死锁以及对共享资源的访问和随时监控线程的状态和执行顺序和线程返回值等就不行了. Callable 和 Future 简介 Callable接口代表一段可以调用并返回结果的代码;Future接口表示是执行异步任务时的状态.返回值等信息.所以说Callable用于产生结果,Future用于获取结果. 1. Callab

并发实现-Callable/Future 实现返回值控制的线程

package chartone; import java.util.concurrent.Callable; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.Future; /** * 并发实现-Callable/Future 实现返回值控制的线程 * * @author suntao * @history 2020-0

java I/O进程控制，重定向 示例代码

package org.rui.io.util; import java.io.*; /** * 标准I/O重定向 */ public class Redircting { public static void main(String[] args) throws IOException { String path="D:\\Users\\liangrui\\workspace\\thinking\\src\\org\\rui\\io\\util/"; PrintStream cons

Java中有返回值的线程，（缓存）线程池的初步使用

一 简介 在JDK1.5以前的线程是没有返回值的(Thread,Runnable),Callable这个接口是之后才出现的新特性,用法跟Runnable类似,只是不同的是可以有返回值.因此为了测试Callable这个类以及线程池相关内容,我将上一篇文章中的代码进行了小幅度的修改然后写了一下 二 关于线程池的简单使用步骤 1 定义线程类,(1)extends Thread (2)implements Runnable (3)implements Callable<> 2 建立ExecutorSe

【多线程】让线程返回值

很多时候,我们使用线程去处理一些业务,并希望得到结果,这时候,我们可以使用Callable. 下面例子,模拟使用线程查询DB得到一个List. 例子 线程,返回一个List数据 package com.nicchagil.study.thread.cnblogs.No02可返回值的线程; import java.util.ArrayList; import java.util.HashMap; import java.util.List; import java.util.Map; import

java多线程总结二：后台线程(守护线程)

所谓的后台线程,是指在程序运行的时候在后台提供一种通用服务的线程,并且这种线程并不属于程序中不可或缺的部分.因此当所有的非后台线程结束时,程序也就终止了,同时会杀死所有后台线程.反过来说,只要有任何非后台线程(用户线程)还在运行,程序就不会终止.后台线程在不执行finally子句的情况下就会终止其run方法.后台线程创建的子线程也是后台线程. 下面是一个后台线程的示例: [java] view plaincopy <span style="font-size:16px;">

Callable 获取线程返回值

allable与 Future 两功能是Java在后续版本中为了适应多并法才加入的,Callable是类似于Runnable的接口,实现Callable接口的类和实现Runnable的类都是可被其他线程执行的任务. Callable的接口定义如下: public interface Callable<V> { V   call()   throws Exception; } Callable和Runnable的区别如下: I    Callable定义的方法是call,而Runnable定义的