基础加强_线程技术相关类一

　　------- android培训、java培训、期待与您交流！ ----------

定时器Timer类的应用

import java.util.Calendar;
import java.util.Timer;
import java.util.TimerTask;


public class TraditionalTimerTest {


	private static int count = 0;
	public static void main(String[] args) {
		
		class MyTimerTask extends TimerTask{			
			@Override
			public void run() {
				count = (count+1)%2;
				System.out.println("bombing!");
				//方法中新建一个计时器，执行本类任务
				new Timer().schedule(new MyTimerTask(),2000+2000*count);
			}
		}
		//启动计时器
		new Timer().schedule(new MyTimerTask(), 2000);
		
		while(true){
			//每秒打印一次秒数
			System.out.println(Calendar.getInstance().get(Calendar.SECOND));//new Date().getSeconds()
			
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

ThreadLocal实现线程范围的共享变量

每个线程调用全局ThreadLocal对象的set方法，就相当于往其内部的map中增加一条记录，key分别是各自的线程，value是各自的set方法传进去的值。在线程结束时可以调用ThreadLocal.clear()方法，释放内存。线程结束后也可以自动释放相关的ThreadLocal变量。

ThreadLocal的应用场景：

订单处理包含一系列操作：

减少库存量、增加一条流水台账、修改总账，这几个操作要在同一个事务中完成，通常也即同一个线程中进行处理，如果累加公司应收款的操作失败了，则应该把前面的操作回滚，否则，提交所有操作，这要求这些操作使用相同的数据库连接对象，而这些操作的代码分别位于不同的模块类中。

银行转账包含一系列操作： 

把转出帐户的余额减少，把转入帐户的余额增加，这两个操作要在同一个事务中完成，它们必须使用相同的数据库连接对象，转入和转出操作的代码分别是两个不同的帐户对象的方法。
例如Strut2的ActionContext，同一段代码被不同的线程调用运行时，该代码操作的数据是每个线程各自的状态和数据，对于不同的线程来说，getContext方法拿到的对象都不相同，对同一个线程来说，不管在哪个模块中调用getContext方法，拿到的都是同一个。

实验案例：定义一个全局共享的ThreadLocal变量，然后启动多个线程向该ThreadLocal变量中存储一个随机值，接着各个线程调用另外其他多个类的方法，这多个类的方法中读取这个ThreadLocal变量的值，就可以看到多个类在同一个线程中共享同一份数据。
 

import java.util.Random;
public class ThreadLocalTest {

	private static ThreadLocal<Integer> x = new ThreadLocal<Integer>();
	public static void main(String[] args) {
		for(int i=0;i<2;i++){
			new Thread(new Runnable(){
				@Override
				public void run() {
					int data = new Random().nextInt();
					System.out.println(Thread.currentThread().getName() 
							+ " has put data :" + data);
					//线程中向ThreadLocal中放的数据是和当前线程相关的
					x.set(data);
					MyThreadScopeData.getThreadInstance().setName("name" + data);
					MyThreadScopeData.getThreadInstance().setAge(data);
					new A().get();
					new B().get();
				}
			}).start();
		}
	}
	
	static class A{
		public void get(){
			int data = x.get();
			System.out.println("A from " + Thread.currentThread().getName() 
					+ " get data :" + data);


			MyThreadScopeData myData = MyThreadScopeData.getThreadInstance();
			System.out.println("A from " + Thread.currentThread().getName() 
					+ " getMyData: " + myData.getName() + "," +
					myData.getAge());
		}
	}
	
	static class B{
		public void get(){
			int data = x.get();			
			System.out.println("B from " + Thread.currentThread().getName() 
					+ " get data :" + data);
			MyThreadScopeData myData = MyThreadScopeData.getThreadInstance();
			System.out.println("B from " + Thread.currentThread().getName() 
					+ " getMyData: " + myData.getName() + "," +
					myData.getAge());			
		}		
	}
}

将MyThreadLocalData封装成具有业务功能的对象，
每个线程只能有一个该类的实例对象，和单例模式差不多。

class MyThreadScopeData{
	private MyThreadScopeData(){}
	//静态的ThreadLocal实例，每个线程访问的是同一个map对象
	private static ThreadLocal<MyThreadScopeData> map = new ThreadLocal<MyThreadScopeData>();
	//不需要加同步，因为对象是和线程相关的。
	public static MyThreadScopeData getThreadInstance(){
		MyThreadScopeData instance = map.get();
		if(instance == null){
			instance = new MyThreadScopeData();
			map.set(instance);
		}
		return instance;
	}
	
	private String name;
	private int age;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
}

小面试题

设计4个线程，其中2个线程每次对j增加1，另外2个线程每次对j减少1；
该方法没有实现顺序

public class ThreadTest1 { 
	//定义j变量，成员位置
	private int j; 


	public static void main(String args[]){ 
		//注意创建内部类对象的方法
		ThreadTest1 tt=new ThreadTest1(); 
		Inc inc=tt.new Inc(); 
		Dec dec=tt.new Dec(); 
		for(int i=0;i<2;i++){ 
			Thread t=new Thread(inc); 
			t.start(); 
			t=new Thread(dec); 
			t.start(); 
		} 
	} 
	//将j++和j--封装成方法，可以加同步
	private synchronized void inc(){ 
		j++; 
		System.out.println(Thread.currentThread().getName()+"-inc:"+j); 
	} 


	private synchronized void dec(){ 
		j--; 
		System.out.println(Thread.currentThread().getName()+"-dec:"+j); 
	} 
	//定义两个Runnable内部类，用于创建进程
	class Inc implements Runnable{ 
		public void run(){ 
			for(int i=0;i<100;i++){ 
				inc(); 
			} 
		} 
	} 


	class Dec implements Runnable{ 
		public void run(){ 
			for(int i=0;i<100;i++){ 
				dec(); 
			} 
		} 
	} 
} 

Java5的线程并发库

java.util.concurrent包
包含并发编程中很常用的实用工具类。
java.util.concurrent.atomic包
类的小工具包，支持在单个变量上解除锁的线程安全编程。
atomic包可以对基本数据，数组中的基本数据，对类中的基本数据进行操作。

线程并发库的应用

线程池的概念和Executors工具类的应用
在线程池的编程模式下，任务是提交给整个线程池，而不是直接交给某个线程，线程池在拿到任务后，它就在内部找有无空闲的线程，再把任务交给内部某个空闲的线程，这就是封装。记住，任务是提交给整个线程池，一个线程同时只能执行一个任务，但可以同时向一个线程池提交多个任务。

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


public class ThreadPoolTest {


	/**
	 * 学习线程池的操作
	 * @param args
	 */
	public static void main(String[] args) {
		//ExecutorService threadPool = Executors.newFixedThreadPool(3);//创建固定大小为3个线程的线程池
		//ExecutorService threadPool = Executors.newCachedThreadPool();//创建一个可根据需要创建新线程的线程池
		ExecutorService threadPool = Executors.newSingleThreadExecutor();//创建单一线程的线程池
		for(int i=1;i<=10;i++){
			final int task = i;//局部内部类访问i可以采取这种方法
			threadPool.execute(new Runnable(){//execute接收一个Runnable对象，执行指定的任务
				@Override
				public void run() {
					for(int j=1;j<=10;j++){
						System.out.println(Thread.currentThread().getName() + " is looping of " + j + " for  task of " + task);
					}
				}
			});
		}
		System.out.println("all of 10 tasks have committed! ");
		//threadPool.shutdownNow();//关闭执行任务，返回未执行的任务列表，threadPool.shutdown();按顺序关闭任务
		//用线程池启动定时器
		Executors.newScheduledThreadPool(3).scheduleAtFixedRate(
				new Runnable(){
					@Override
				public void run() {
					System.out.println("bombing!");					
				}},
				6,
				2,
				TimeUnit.SECONDS);
	}


}

Callable和Futrue的应用

Callable<T> 类似Runnable，call方法可以返回结果
Future取得的结果类型和Callable返回的结果类型必须一致，这是通过泛型来实现的。
Callable要采用ExecutorSevice的submit方法提交，返回的future对象可以取消任务。
CompletionService用于提交一组Callable任务，其take方法返回已完成的一个Callable任务对应的Future对象。

public class CallableAndFuture {


	/**
	 * @param args
	 */
	public static void main(String[] args) {
		ExecutorService threadPool =  Executors.newSingleThreadExecutor();//创建一个线程池
		Future<String> future =
			threadPool.submit(//通过线程池的submit方法提交Callable，返回future对象
				new Callable<String>() {
					public String call() throws Exception {
						Thread.sleep(2000);
						return "hello";
					};
				}
		);
		System.out.println("等待结果");
		try {
			System.out.println("拿到结果：" + future.get());//通过future的get方法获得返回值
		} catch (Exception e) {
			e.printStackTrace();
		}
		
		ExecutorService threadPool2 =  Executors.newFixedThreadPool(10);
		CompletionService<Integer> completionService = new ExecutorCompletionService<Integer>(threadPool2);
		for(int i=1;i<=10;i++){
			final int seq = i;
			completionService.submit(new Callable<Integer>() {
				@Override
				public Integer call() throws Exception {
					Thread.sleep(new Random().nextInt(5000));
					return seq;
				}
			});
		}
		for(int i=0;i<10;i++){
			try {
				System.out.println(
						completionService.take().get());//take方法返回已经完成的future
			} catch (Exception e) {
				e.printStackTrace();
			} 
		}
	}
}

　　------- android培训、java培训、期待与您交流！ ----------