Java线程新特征——Java并发库详解编程语言

import java.util.concurrent.Executors;  
import java.util.concurrent.ExecutorService;  
 
/**  
* Java线程：线程池-  
*  
* */  
public class Test {  
        public static void main(String[] args) {  
                //创建一个可重用固定线程数的线程池  
                ExecutorService pool = Executors.newFixedThreadPool(2);  
                //创建实现了Runnable接口对象，Thread对象当然也实现了Runnable接口  
                Thread t1 = new MyThread();  
                Thread t2 = new MyThread();  
                Thread t3 = new MyThread();  
                Thread t4 = new MyThread();  
                Thread t5 = new MyThread();  
                //将线程放入池中进行执行  
                pool.execute(t1);  
                pool.execute(t2);  
                pool.execute(t3);  
                pool.execute(t4);  
                pool.execute(t5);  
                //关闭线程池  
                pool.shutdown();  
        }  
}  
 
class MyThread extends Thread{  
        @Override  
        public void run() {  
                System.out.println(Thread.currentThread().getName()+"正在执行...");  
        }  
}

pool-1-thread-1正在执行... 
pool-1-thread-1正在执行... 
pool-1-thread-2正在执行... 
pool-1-thread-1正在执行... 
pool-1-thread-2正在执行...

pool-1-thread-2正在执行... 
pool-1-thread-3正在执行... 
pool-1-thread-3正在执行... 
pool-1-thread-2正在执行... 
pool-1-thread-1正在执行...

 //创建一个使用单个 worker 线程的 Executor，以无界队列方式来运行该线程。  
ExecutorService pool = Executors.newSingleThreadExecutor(); 

pool-1-thread-1正在执行... 
pool-1-thread-1正在执行... 
pool-1-thread-1正在执行... 
pool-1-thread-1正在执行... 
pool-1-thread-1正在执行...

  //创建一个可根据需要创建新线程的线程池，但是在以前构造的线程可用时将重用它们。  
   ExecutorService pool = Executors.newCachedThreadPool(); 

package MultiThread; 
import java.util.concurrent.ExecutorService;  
import java.util.concurrent.Executors;  
import java.util.concurrent.locks.Lock;  
import java.util.concurrent.locks.ReadWriteLock; 
import java.util.concurrent.locks.ReentrantLock;  
import java.util.concurrent.locks.ReentrantReadWriteLock; 
/**  
* Java线程：锁  
*  
*  
*/  
public class Test {  
public static void main(String[] args) {  
//创建并发访问的账户  
MyCount myCount = new MyCount("95599200901215522", 10000);  
//创建一个锁对象  
ReadWriteLock lock = new ReentrantReadWriteLock();  
//创建一个线程池  
ExecutorService pool = Executors.newCachedThreadPool();  
//创建一些并发访问用户线程，一个信用卡，存的存，取的取，好热闹啊  
UserThread ut1 = new UserThread("取款线程1", myCount, -4000, lock,false);  
UserThread ut2 = new UserThread("存款线程1", myCount, 6000, lock,false);  
UserThread ut3 = new UserThread("取款线程2", myCount, -8000, lock,false);  
UserThread ut4 = new UserThread("存款线程2", myCount, 800, lock,false);  
UserThread ut5 = new UserThread("查询", myCount, 0, lock,true); 
//在线程池中执行各个用户的操作  
                pool.execute(ut1);  
pool.execute(ut2);  
pool.execute(ut3);  
pool.execute(ut4);  
pool.execute(ut5); 
//关闭线程池  
                pool.shutdown();  
}  
}  
/**  
* 信用卡的用户 线程 
* 多个用户线程操作该信用卡 
*/  
class UserThread implements Runnable {  
private String threadName;                //用户线程  
private MyCount myCount;        //所要操作的账户  
private int iocash;                 //操作的金额，当然有正负之分了  
private ReadWriteLock myLock;                //执行操作所需的锁对象  
private boolean ischeck;      //是否查询 
 
UserThread(String name, MyCount myCount, int iocash, ReadWriteLock myLock,boolean ischeck) {  
this.threadName = name;  
this.myCount = myCount;  
this.iocash = iocash;  
this.myLock = myLock;  
this.ischeck=ischeck; 
}  
public void run() { 
if(ischeck){ 
//获取读锁  
                myLock.readLock().lock();  
//执行查询 
System.out.println("读："+threadName + "正在查询" + myCount + "账户，，当前金额为" + myCount.getCash());  
//释放获取到的读锁 
                myLock.readLock().unlock(); 
}else{ 
//获取写锁 
                myLock.writeLock().lock(); 
myCount.setCash(myCount.getCash() + iocash);  
System.out.println("写："+threadName+"操作成功，操作金额为" + iocash + "，当前金额为" + myCount.getCash());  
//释放锁获取到的写锁 
                myLock.writeLock().unlock();  
} 
}  
}  
/**  
* 信用卡账户，可随意透支  
*/  
class MyCount {  
private String oid;         //账号  
private int cash;             //账户余额  
 
MyCount(String oid, int cash) {  
this.oid = oid;  
this.cash = cash;  
}  
public String getOid() {  
return oid;  
}  
public void setOid(String oid) {  
this.oid = oid;  
}  
public int getCash() {  
return cash;  
}  
public void setCash(int cash) {  
this.cash = cash;  
}  
@Override  
public String toString() {  
return "MyCount{" +  
"oid='" + oid + '/'' +  
", cash=" + cash +  
'}';  
}  
}

写：取款线程1操作成功，操作金额为-4000，当前金额为6000 
写：取款线程2操作成功，操作金额为-8000，当前金额为-2000 
写：存款线程1操作成功，操作金额为6000，当前金额为4000 
读：查询正在查询MyCount{oid='95599200901215522', cash=4000}账户，，当前金额为4000 
写：存款线程2操作成功，操作金额为800，当前金额为4800

package MultiThread; 
import java.util.concurrent.ExecutorService;  
import java.util.concurrent.Executors;  
import java.util.concurrent.Semaphore;  
/**  
* Java线程：信号量  
*  
*  
*/  
public class Test {  
public static void main(String[] args) {  
MyPool myPool = new MyPool(20);  
//创建线程池  
ExecutorService threadPool = Executors.newFixedThreadPool(2);  
MyThread t1 = new MyThread("任务A", myPool, 3);  
MyThread t2 = new MyThread("任务B", myPool, 12);  
MyThread t3 = new MyThread("任务C", myPool, 7);  
//在线程池中执行任务  
                threadPool.execute(t1);  
threadPool.execute(t2);  
threadPool.execute(t3);  
//关闭池  
                threadPool.shutdown();  
}  
}  
/**  
* 一个池  
*/  
class MyPool {  
private Semaphore sp;     //池相关的信号量  
/**  
* 池的大小，这个大小会传递给信号量  
*  
* @param size 池的大小  
*/  
MyPool(int size) {  
this.sp = new Semaphore(size);  
}  
public Semaphore getSp() {  
return sp;  
}  
public void setSp(Semaphore sp) {  
this.sp = sp;  
}  
}  
class MyThread extends Thread {  
private String threadName;            //线程的名称  
private MyPool pool;                        //自定义池  
private int x;                                    //申请信号量的大小  
 
MyThread(String threadName, MyPool pool, int x) {  
this.threadName = threadName;  
this.pool = pool;  
this.x = x;  
}  
public void run() {  
try {  
//从此信号量获取给定数目的许可  
                        pool.getSp().acquire(x);  
//todo：也许这里可以做更复杂的业务  
System.out.println(threadName + "成功获取了" + x + "个许可！");  
} catch (InterruptedException e) {  
e.printStackTrace();  
} finally {  
//释放给定数目的许可，将其返回到信号量。  
                        pool.getSp().release(x);  
System.out.println(threadName + "释放了" + x + "个许可！");  
}  
}  
}

任务A成功获取了3个许可！ 
任务B成功获取了12个许可！ 
任务B释放了12个许可！ 
任务C成功获取了7个许可！ 
任务A释放了3个许可！ 
任务C释放了7个许可！

package MultiThread; 
import java.util.concurrent.ExecutorService;  
import java.util.concurrent.Executors;  
import java.util.concurrent.locks.Condition;  
import java.util.concurrent.locks.Lock;  
import java.util.concurrent.locks.ReentrantLock;  
/**  
* Java线程：条件变量  
*  
* @author leizhimin 2009-11-5 10:57:29  
*/  
public class Test {  
public static void main(String[] args) {  
//创建并发访问的账户  
MyCount myCount = new MyCount("95599200901215522", 10000);  
//创建一个线程池  
ExecutorService pool = Executors.newFixedThreadPool(2);  
Thread t1 = new SaveThread("张三", myCount, 2000);  
Thread t2 = new SaveThread("李四", myCount, 3600);  
Thread t3 = new DrawThread("王五", myCount, 2700);  
Thread t4 = new SaveThread("老张", myCount, 600);  
Thread t5 = new DrawThread("老牛", myCount, 1300);  
Thread t6 = new DrawThread("胖子", myCount, 800);  
//执行各个线程  
                pool.execute(t1);  
pool.execute(t2);  
pool.execute(t3);  
pool.execute(t4);  
pool.execute(t5);  
pool.execute(t6);  
//关闭线程池  
                pool.shutdown();  
}  
}  
/**  
* 存款线程类  
*/  
class SaveThread extends Thread {  
private String name;                //操作人  
private MyCount myCount;        //账户  
private int x;                            //存款金额  
 
SaveThread(String name, MyCount myCount, int x) {  
this.name = name;  
this.myCount = myCount;  
this.x = x;  
}  
public void run() {  
myCount.saving(x, name);  
}  
}  
/**  
* 取款线程类  
*/  
class DrawThread extends Thread {  
private String name;                //操作人  
private MyCount myCount;        //账户  
private int x;                            //存款金额  
 
DrawThread(String name, MyCount myCount, int x) {  
this.name = name;  
this.myCount = myCount;  
this.x = x;  
}  
public void run() {  
myCount.drawing(x, name);  
}  
}  
/**  
* 普通银行账户，不可透支  
*/  
class MyCount {  
private String oid;                         //账号  
private int cash;                             //账户余额  
private Lock lock = new ReentrantLock();                //账户锁  
private Condition _save = lock.newCondition();    //存款条件  
private Condition _draw = lock.newCondition();    //取款条件  
 
MyCount(String oid, int cash) {  
this.oid = oid;  
this.cash = cash;  
}  
/**  
* 存款  
*  
* @param x    操作金额  
* @param name 操作人  
*/  
public void saving(int x, String name) {  
lock.lock();                        //获取锁  
if (x > 0) {  
cash += x;                    //存款  
System.out.println(name + "存款" + x + "，当前余额为" + cash);  
}  
_draw.signalAll();            //唤醒所有取款等待线程 
lock.unlock();                    //释放锁  
        }  
/**  
* 取款  
*  
* @param x    操作金额  
* @param name 操作人  
*/  
public void drawing(int x, String name) {  
lock.lock();                                 //获取锁  
try {  
if (cash - x < 0) {  
_draw.await();             //阻塞取款操作  
} else {  
cash -= x;                     //取款  
System.out.println(name + "取款" + x + "，当前余额为" + cash);  
}  
_save.signalAll();             //唤醒所有存款操作线程  
} catch (InterruptedException e) {  
e.printStackTrace();  
} finally {  
lock.unlock();                     //释放锁  
                }  
}  
}

package MultiThread; 
import java.util.concurrent.BrokenBarrierException;  
import java.util.concurrent.CyclicBarrier;  
/**  
* Java线程：新特征-障碍器  
*  
*   
*/  
public class Test {  
public static void main(String[] args) {  
//创建障碍器，并设置MainTask为所有定数量的线程都达到障碍点时候所要执行的任务(Runnable)  
CyclicBarrier cb = new CyclicBarrier(7, new MainTask());  
new SubTask("A", cb).start();  
new SubTask("B", cb).start();  
new SubTask("C", cb).start();  
new SubTask("D", cb).start();  
new SubTask("E", cb).start();  
new SubTask("F", cb).start();  
new SubTask("G", cb).start();  
}  
}  
/**  
* 主任务  
*/  
class MainTask implements Runnable {  
public void run() {  
System.out.println(">>>>主任务执行了！<<<<");  
}  
}  
/**  
* 子任务  
*/  
class SubTask extends Thread {  
private String name;  
private CyclicBarrier cb;  
SubTask(String name, CyclicBarrier cb) {  
this.name = name;  
this.cb = cb;  
}  
public void run() {  
System.out.println("[子任务" + name + "]开始执行了！");  
for (int i = 0; i < 999999; i++) ;    //模拟耗时的任务  
System.out.println("[子任务" + name + "]开始执行完成了，并通知障碍器已经完成！");  
try {  
//通知障碍器已经完成，让出锁（并使得，跳跃的障碍数目-1） 
                        cb.await();  
} catch (InterruptedException e) {  
e.printStackTrace();  
} catch (BrokenBarrierException e) {  
e.printStackTrace();  
}  
}  
}

[子任务B]开始执行了！ 
[子任务E]开始执行了！ 
[子任务C]开始执行了！ 
[子任务D]开始执行了！ 
[子任务A]开始执行了！ 
[子任务E]开始执行完成了，并通知障碍器已经完成！ 
[子任务B]开始执行完成了，并通知障碍器已经完成！ 
[子任务A]开始执行完成了，并通知障碍器已经完成！ 
[子任务C]开始执行完成了，并通知障碍器已经完成！ 
[子任务D]开始执行完成了，并通知障碍器已经完成！ 
[子任务F]开始执行了！ 
[子任务F]开始执行完成了，并通知障碍器已经完成！ 
[子任务G]开始执行了！ 
[子任务G]开始执行完成了，并通知障碍器已经完成！ 
>>>>主任务执行了！<<<<