JAVA简易数据连接池Condition

用Condition和synchronized：

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.LinkedList;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class MyDataSource {
	// 不停的增删改
	private LinkedList<Connection> pool = new LinkedList<>();
	private static final int INIT_CONNECTIONS = 10;
	private static final String DRIVER_CLASS = "";
	private static final String USER = "";
	private static final String PASSWORD = "";
	private static final String URL = "";

	private Lock lock = new ReentrantLock();
	private Condition c1 = lock.newCondition();

	static {
		try {
			Class.forName("com.mysql.jdbc.Driver");
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
	}

	public MyDataSource() {
		for (int i = 0; i < INIT_CONNECTIONS; i++) {
			try {
				Connection conn = DriverManager.getConnection(URL, USER, PASSWORD);
				pool.addLast(conn);
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
	}

	public Connection getConnection() {
		Connection result = null;
		lock.lock();
		try {
			while (pool.size() <= 0) {
				try {
					c1.await();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
			if (!pool.isEmpty()) {
				result = pool.removeFirst();
			}

			return result;
		} finally {
			lock.unlock();
		}
	}

	public Connection getConnectionSynchronized() {
		Connection result = null;
		synchronized (pool) {
			while (pool.size() <= 0) {
				try {
					wait();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
			if (!pool.isEmpty()) {
				result = pool.removeFirst();
			}
		}
		return result;
	}
    public void release(Connection conn){
    	if(conn!=null){
    		lock.lock();
    		try {
				pool.addLast(conn);
				c1.signal(); 
			} finally {
				lock.unlock();
			}
    	}
    }
	public void releaseSynchronized(Connection conn) {
		if (conn != null) {
			synchronized (pool) {
				pool.addLast(conn);
				notifyAll();
			}
		}
	}
}

　　线程之间的通信-join

public class Demo {
    public void a(Thread joinThread){
    	System.out.println("方法a执行了。。。。");
    	joinThread.start();
    	try {
			joinThread.join();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
    	System.out.println("a方法执行完毕。。。");
    }
    public void b(){
    	System.out.println("加塞线程开始执行");
    	try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
    	System.out.println("加塞线程执行完毕...");
    }
    public static void main(String[] args) {
		Demo demo=new Demo();
		Thread joinThread=new Thread(new Runnable() {
			@Override
			public void run() {
				demo.b();
			}
		});
		new Thread(new Runnable() {
			@Override
			public void run() {
				demo.a(joinThread);
			}
		}).start();
	}
}

　　ThreadLocal：

public class Demo99 {
	private ThreadLocal<Integer> count = 
			new ThreadLocal<Integer>() {
		protected Integer initialValue() {
			return new Integer(0);
		};
	};

	public int getNext() {
		Integer value = count.get();
		value++;
		count.set(value);
		return value;
	}

	public static void main(String[] args) {
		Demo99 d=new Demo99();
		new Thread(new Runnable() {
			@Override
			public void run() {
				while (true) {
					System.out.println(
							Thread.currentThread().getName() + " " + 
					d.getNext());
					try {
						Thread.sleep(1000);
					} catch (InterruptedException e) {
						
						e.printStackTrace();
					}
				}
			}
		}).start();
		new Thread(new Runnable() {
			@Override
			public void run() {
				while (true) {
					System.out.println(
							Thread.currentThread().getName() + " " + 
					d.getNext());
					try {
						Thread.sleep(1000);
					} catch (InterruptedException e) {
						
						e.printStackTrace();
					}
				}
			}
		}).start();
		
	}
}

　　线程之间的通讯：CountDownLatch

 

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

public class Demo {
	private int[] nums;

	public Demo(int line) {
		nums = new int[line];
	}

	public void calc(String line, int index) {

		String[] nus = line.split(",");// 切分出每一个值
		int total = 0;
		for (String num : nus) {
			total += Integer.parseInt(num);
		}
		nums[index] = total;// 把计算的结果放到数组中指点的位置
		System.out.println(Thread.currentThread().getName() + "行计划任务...." + line + "结果为：" + total);
	}

	public void sum() {
		System.out.println("汇总线程开始执行....");
		int total = 0;
		for (int i = 0; i < nums.length; i++) {
			total += nums[i];
		}
		System.out.println("最终的结果为：" + total);
	}

	public static void main(String[] args) {
		List<String> contents = readFile();
		int lineCount = contents.size();
		Demo d = new Demo(lineCount);
		for (int i = 0; i < lineCount; i++) {
			final int j = i;
			new Thread(new Runnable() {
				@Override
				public void run() {
					d.calc(contents.get(j), j);
				}
			}).start();
		}
		while (Thread.activeCount() > 1) {

		}
		d.sum();
	}

	private static List<String> readFile() {
		List<String> contents = new ArrayList<>();
		String line = null;
		BufferedReader br = null;
		try {
			br = new BufferedReader(new FileReader("e:\\num.txt"));
			while ((line = br.readLine()) != null) {
				contents.add(line);
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if (br != null) {
				try {
					br.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
		return contents;
	}
}

　　

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CountDownLatch;

public class Demo2 {
	private int[] nums;

	public Demo2(int line) {
		nums = new int[line];
	}

	public void calc(String line, int index,CountDownLatch latch) {

		String[] nus = line.split(",");// 切分出每一个值
		int total = 0;
		for (String num : nus) {
			total += Integer.parseInt(num);
		}
		nums[index] = total;// 把计算的结果放到数组中指点的位置
		System.out.println(Thread.currentThread().getName() + "行计划任务...." + line + "结果为：" + total);
	    latch.countDown();
	}

	public void sum() {
		System.out.println("汇总线程开始执行....");
		int total = 0;
		for (int i = 0; i < nums.length; i++) {
			total += nums[i];
		}
		System.out.println("最终的结果为：" + total);
	}

	public static void main(String[] args) {
		List<String> contents = readFile();
		int lineCount = contents.size();
		CountDownLatch latch=new CountDownLatch(lineCount);
		Demo2 d = new Demo2(lineCount);
		for (int i = 0; i < lineCount; i++) {
			final int j = i;
			new Thread(new Runnable() {
				@Override
				public void run() {
					d.calc(contents.get(j), j,latch);
				}
			}).start();
		}
		try {
			latch.await();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		d.sum();
	}

	private static List<String> readFile() {
		List<String> contents = new ArrayList<>();
		String line = null;
		BufferedReader br = null;
		try {
			br = new BufferedReader(new FileReader("e:\\num.txt"));
			while ((line = br.readLine()) != null) {
				contents.add(line);
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if (br != null) {
				try {
					br.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
		return contents;
	}
}

　　线程之间的通信：CyclicBarrier  达到屏障点之后，后面的线程才继续执行

import java.util.Random;
import java.util.concurrent.CyclicBarrier;

public class Demo {
	Random random = new Random();

	public void meeting(CyclicBarrier barrier) {
		try {
			Thread.sleep(random.nextInt(4000));
		} catch (InterruptedException e1) {
			// TODO Auto-generated catch block
			e1.printStackTrace();
		}
		System.out.println(Thread.currentThread().getName() + "到达会议室，等待开会...");
		if(Thread.currentThread().getName().equals("Thread-1")){
			throw new RuntimeException();
		}
		try {
			barrier.await();
		} catch (Exception e) {
			e.printStackTrace();
		}
		System.out.println(Thread.currentThread().getName()+"发言");
	}

	public static void main(String[] args) {
		Demo demo = new Demo();
		CyclicBarrier barrier = new CyclicBarrier(10, new Runnable() {
			@Override
			public void run() {
				System.out.println("好，我们开始开会.....");
			}
		});
		for (int i = 0; i < 10; i++) {
			new Thread(new Runnable() {
				@Override
				public void run() {
					demo.meeting(barrier);
				}
			}).start();
		}
	}
}　　

 线程之间的通讯：Semaphore：能控制被多少个线程同时访问

import java.util.concurrent.Semaphore;

public class Demo22 {
    public void method(Semaphore semaphore){
    	try {
			semaphore.acquire();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
    	System.out.println(Thread.currentThread().getName()+"is run...");
    	try {
			Thread.sleep(2000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
    	semaphore.release();
    }
    public static void main(String[] args) {
		Demo22 d=new Demo22();
		Semaphore semaphore=new Semaphore(10);
		while (true) {
			new Thread(new Runnable() {
				@Override
				public void run() {
					d.method(semaphore);
				}
			}).start();
			
		}
	}
}

　　Exchanger：

import java.util.concurrent.Exchanger;

public class Demo33 {
    public void a(Exchanger<String> exch){
    	System.out.println("a 方法执行....");
    	try {
    		System.out.println("a 线程正在抓取数据....");
			Thread.sleep(2000);
			System.out.println("a 抓取到数据.....");
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
    	String res="12345";
    	try {
    		System.out.println("等待对比结果....");
			exch.exchange(res);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
    }
    public void b(Exchanger<String> exch){
    	System.out.println("b 方法开始执行....");
    	try {
    		System.out.println("b 方法开始抓取数据....");
			Thread.sleep(4000);
			System.out.println("b 方法抓取数据结束....");
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
    	String res="12345";
    	try {
    		String value=exch.exchange(res);
    		System.out.println("开始进行比对.....");
    		System.out.println("比对结果为："+value.equals(res));
			
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
    }
    public static void main(String[] args) {
    	Demo33 d=new Demo33();
    	Exchanger<String> exch=new Exchanger<>();
		new Thread(new Runnable() {
			@Override
			public void run() {
			    d.a(exch);
			}
		}).start();
		new Thread(new Runnable() {
			@Override
			public void run() {
			    d.b(exch);
			}
		}).start();
	}
}

　　提前完成任务Future使用：

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

public class Demo44 {
public static void main(String[] args)  throws Exception{
	Callable<Integer> call=new Callable<Integer>() {
		@Override
		public Integer call() throws Exception{
			System.out.println("正在计算结果....");
			Thread.sleep(3000);
			return 1;
		}
	};
	FutureTask<Integer> task=new FutureTask<>(call);
	Thread thread=new Thread(task);
	thread.start();
	
	//do something
	System.out.println("干点别的...");
	Integer result=task.get();
	System.out.println("拿到的结果为："+result);
}
}

　　用买蛋糕和去上班的例子说明 ：

public class Product {
     private int id;
     private String name;
     public int getId() {
		return id;
	}
     public void setId(int id) {
		this.id = id;
	}
     public String getName() {
		return name;
	}
    public void setName(String name) {
		this.name = name;
	}
    @Override
    public String toString() {
    	return "Product [id="+id+",name="+name+"]";
    }
    public Product(int id,String name) {
    	try {
    		System.out.println("开始生产"+name);
			Thread.sleep(4000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		this.id=id;
		this.name=name;
		System.out.println(name+"生产完毕");
	}
}

　　

public class Future {
   private Product product;
   private boolean down;
   public synchronized void setProduct(Product product){
	   if(down) return;
       
	   this.product=product;
	   this.down=true;
	   notifyAll();
   }
   public synchronized Product get(){
	   while(!down){
		   try {
			wait();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	   }
	   return product;
   }
}

　　

import java.util.Random;

public class ProductFactory {
    public Future createProduct(String name){
    	Future f=new Future();//创建一个订单
    	System.out.println("下单成功，你可以去上班了...");
    	 //生产产品
    	new Thread(new Runnable() {
			@Override
			public void run() {
				Product p=new Product(new Random().nextInt(), name);
		    	f.setProduct(p);
			}
		}).start();

    	return f;
    }
}

　　

import java.util.Random;

public class ProductFactory {
    public Future createProduct(String name){
    	Future f=new Future();//创建一个订单
    	System.out.println("下单成功，你可以去上班了...");
    	 //生产产品
    	new Thread(new Runnable() {
			@Override
			public void run() {
				Product p=new Product(new Random().nextInt(), name);
		    	f.setProduct(p);
			}
		}).start();

    	return f;
    }
}

　　Callalbe和Runnable的区别：

Runnable run方法是被线程调用的，在run方法是异步执行的

Callable的call方法，不是异步执行的，是由Future的Run方法调用的

ForkJoin：

import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ForkJoinTask;
import java.util.concurrent.RecursiveTask;

public class Demo extends RecursiveTask<Integer>{
	private int begin;
	private int end;
	public Demo(int begin,int end){
		this.begin=begin;
		this.end=end;
	}
	@Override
	protected Integer compute(){
		int sum=0;
		
		//拆分任务
		if(end-begin<=2){
			//计算
			for(int i=begin;i<=end;i++){
				sum+=i;
			}
		}else{ //拆分
			Demo d1=new Demo(begin,(begin+end)/2);
			Demo d2=new Demo((begin+end)/2+1,end);
			//执行任务
			d1.fork();
			d2.fork();
			
			Integer a=d1.join();
			Integer b=d2.join();
			sum=a+b;
		}
		return sum;
	}
	public static void main(String[] args) throws Exception {
		ForkJoinPool pool=new ForkJoinPool();
	    ForkJoinTask<Integer> future=pool.submit(new Demo(1,100));
	    System.out.println("......");
	    System.out.println("计算的值为："+future.get());
	}

}