Java线程：条件变量、原子量、线程池等
一、条件变量
条件变量实现了java.util.concurrent.locks.Condition接口，条件变量的实例化就是通过一个Lock对象上调用newCondition()方法获得的，这样条件就和一个锁绑定起来了。因此，Java中的条件变量只能和锁配合使用，来控制并发程序访问竞争资源的安全。
条件变量的出现是为了更精细的控制线程等待与唤醒，一个锁可以有多个条件，每个条件上有多个线程等待，通过await()方法，可以让线程在该条件下等待。当调用signalAll()方法时，又可以唤醒该条件下等待的线程。条件变量比较抽象，原因是它不是自然语言中的条件概念，而是控制程序的一种手段。
看个例子，有一个账户，多个用户(线程)在同时操作这个账户，有的存款有的取款，存款随便存，但取款有限制，不能透支，任何试图透支的操作都将等待里面有足够的存款时才执行操作。
CaseTest.java
package Thread;
import java.util.*;
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;
public class CaseTest {
public static void main(String[] args){
MyCount1 myCount1=new MyCount1("6516431",10000);
ExecutorService pool=Executors.newFixedThreadPool(2);
Thread t1=new SaveThread("张三",myCount1,2000);
Thread t2=new DrawThread("李四",myCount1,3600);
Thread t3=new SaveThread("王二",myCount1,2700);
Thread t4=new SaveThread("麻子",myCount1,600);
Thread t5=new DrawThread("胖子",myCount1,1300);
Thread t6=new DrawThread("小刘",myCount1,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 MyCount1 myCount1;
private int x;
SaveThread(String name,MyCount1 myCount1,int x){
this.name=name;
this.myCount1=myCount1;
this.x=x;
}
public void run(){
myCount1.saving(x,name);
}
}
class DrawThread extends Thread{
private String name;
private MyCount1 myCount;
private int x;
DrawThread(String name,MyCount1 myCount,int x){
this.name=name;
this.myCount=myCount;
this.x=x;
}
public void run(){
myCount.drawing(x,name);
}
}
class MyCount1{
private String oid;
private int cash;
private Lock lock=new ReentrantLock();
private Condition _save=lock.newCondition();
private Condition _draw=lock.newCondition();
MyCount1(String oid,int cash){
this.oid=oid;
this.cash=cash;
}
public void saving(int x,String name){
lock.lock(); //获取锁
if(x>0){
cash+=x;
System.out.println(name+"存款"+x+",当前余额为："+cash);
}
_draw.signalAll(); //唤醒所有等待线程。
lock.unlock(); //释放锁
}
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();
}
}
}
结果为：
李四取款3600,当前余额为：6400
张三存款2000,当前余额为：8400
王二存款2700,当前余额为：11100
麻子存款600,当前余额为：11700
胖子取款1300,当前余额为：10400
小刘取款800,当前余额为：9600
如果不用条件变量和锁，如何实现此功能呢？
CaseTest.java
package Thread;
import java.util.*;
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;
public class CaseTest {
public static void main(String[] args){
MyCount1 myCount1=new MyCount1("6516431",10000);
ExecutorService pool=Executors.newFixedThreadPool(2);
Thread t1=new SaveThread("张三",myCount1,2000);
Thread t2=new DrawThread("李四",myCount1,3600);
Thread t3=new SaveThread("王二",myCount1,2700);
Thread t4=new SaveThread("麻子",myCount1,600);
Thread t5=new DrawThread("胖子",myCount1,1300);
Thread t6=new DrawThread("小刘",myCount1,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 MyCount1 myCount1;
private int x;
SaveThread(String name,MyCount1 myCount1,int x){
this.name=name;
this.myCount1=myCount1;
this.x=x;
}
public void run(){
myCount1.saving(x,name);
}
}
class DrawThread extends Thread{
private String name;
private MyCount1 myCount;
private int x;
DrawThread(String name,MyCount1 myCount,int x){
this.name=name;
this.myCount=myCount;
this.x=x;
}
public void run(){
myCount.drawing(x,name);
}
}
class MyCount1{
private String oid;
private int cash;
MyCount1(String oid,int cash){
this.oid=oid;
this.cash=cash;
}
public synchronized void saving(int x,String name){
if(x>0){
cash+=x;
System.out.println(name+"存款"+x+",当前余额为："+cash);
}
notifyAll();
//_draw.signalAll(); //唤醒所有等待线程。
//lock.unlock(); //释放锁
}
public synchronized void drawing(int x,String name){
if(cash-x<0){
try{
wait();
}
catch(InterruptedException e){
e.printStackTrace();
}
}else{
cash-=x;
System.out.println(name+"取款"+x+",当前余额为："+cash);
}
notifyAll(); }
}
第二种方式是用同步方法的第一种方法，以前说过这种方法不如第二种好，下面改进一下该同步的程序：
CaseTest.java
package Thread;
import java.util.*;
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;
public class CaseTest {
public static void main(String[] args){
MyCount1 myCount1=new MyCount1("6516431",10000);
ExecutorService pool=Executors.newFixedThreadPool(2);
Thread t1=new SaveThread("张三",myCount1,2000);
Thread t2=new DrawThread("李四",myCount1,3600);
Thread t3=new SaveThread("王二",myCount1,2700);
Thread t4=new SaveThread("麻子",myCount1,600);
Thread t5=new DrawThread("胖子",myCount1,1300);
Thread t6=new DrawThread("小刘",myCount1,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 MyCount1 myCount1;
private int x;
SaveThread(String name,MyCount1 myCount1,int x){
this.name=name;
this.myCount1=myCount1;
this.x=x;
}
public void run(){
myCount1.saving(x,name);
}
}
class DrawThread extends Thread{
private String name;
private MyCount1 myCount;
private int x;
DrawThread(String name,MyCount1 myCount,int x){
this.name=name;
this.myCount=myCount;
this.x=x;
}
public void run(){
myCount.drawing(x,name);
}
}
class MyCount1{
private String oid;
private int cash;
//private Lock lock=new ReentrantLock();
//private Condition _save=lock.newCondition();
//private Condition _draw=lock.newCondition();
MyCount1(String oid,int cash){
this.oid=oid;
this.cash=cash;
}
public void saving(int x,String name){
synchronized(this){
if(x>0){
cash+=x;
System.out.println(name+"存款"+x+",当前余额为："+cash);
}
notifyAll();
}
}
public void drawing(int x,String name){
synchronized(this){
if(cash-x<0){
try{
wait();
}
catch(InterruptedException e){
e.printStackTrace();
}
}else{
cash-=x;
System.out.println(name+"取款"+x+",当前余额为："+cash);
}
notifyAll();
}
}
}
二、Volatile变量
具体的内容，详见 JAVA理论与实践：正确使用Volatile变量
三、原子量
所谓原子量就是操作变量的操作是“原子的”，该操作不可再分，因此线程是安全的。volatile、synchronized关键字来解决并发访问的安全问题，但这样太麻烦。有一个用来进行单变量多线程并发安全访问的工具包java.util.concurrent.atmoic。
Test.java
package Thread;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicLong;
public class CaseTest {
public static void main(String[] args){
ExecutorService pool=Executors.newFixedThreadPool(2);
Runnable t1=new MyRunnable_2("张三",2000);
Runnable t2=new MyRunnable_2("李四",3600);
Runnable t3=new MyRunnable_2("王二",2700);
Runnable t4=new MyRunnable_2("麻子",600);
Runnable t5=new MyRunnable_2("胖子",1300);
Runnable t6=new MyRunnable_2("小刘",800);
pool.execute(t1);
pool.execute(t2);
pool.execute(t3);
pool.execute(t4);
pool.execute(t5);
pool.execute(t6);
pool.shutdown();
}
}
class MyRunnable_2 implements Runnable{
private static AtomicLong aLong = new AtomicLong(10000);
private String name;
private int x;
MyRunnable_2(String name,int x){
this.name=name;
this.x=x;
}
public void run(){
System.out.println(name+"执行了"+x+",余额为："+aLong.addAndGet(x));
}
}
结果为
/**第一种结果**/
张三执行了2000,余额为：12000
王二执行了2700,余额为：14700
麻子执行了600,余额为：15300
胖子执行了1300,余额为：16600
小刘执行了800,余额为：17400
李四执行了3600,余额为：21000 /**第二种结果**/
张三执行了2000,余额为：15600
李四执行了3600,余额为：13600
王二执行了2700,余额为：18300
麻子执行了600,余额为：18900
胖子执行了1300,余额为：20200
小刘执行了800,余额为：21000
这个例子是个反例，可见到虽然使用了原子量，但是并发访问还是有问题，那么问题在哪？原子量虽然可以保证单个变量在某一个操作过程安全，但无法保证整个代码块，或者说整个程序的安全。因此，通常可以使用锁等同步机制控制整个程序的安全性。
Test.java
package Thread;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicLong;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class CaseTest {
public static void main(String[] args){
ExecutorService pool=Executors.newFixedThreadPool(2);
Lock lock=new ReentrantLock(false);
Runnable t1=new MyRunnable_2("张三",2000,lock);
Runnable t2=new MyRunnable_2("李四",3600,lock);
Runnable t3=new MyRunnable_2("王二",2700,lock);
Runnable t4=new MyRunnable_2("麻子",600,lock);
Runnable t5=new MyRunnable_2("胖子",1300,lock);
Runnable t6=new MyRunnable_2("小刘",800,lock);
pool.execute(t1);
pool.execute(t2);
pool.execute(t3);
pool.execute(t4);
pool.execute(t5);
pool.execute(t6);
pool.shutdown();
}
}
class MyRunnable_2 implements Runnable{
private static AtomicLong aLong = new AtomicLong(10000);
private String name;
private int x;
private Lock lock;
MyRunnable_2(String name,int x,Lock lock){
this.name=name;
this.x=x;
this.lock=lock;
}
public void run(){
lock.lock();
System.out.println(name+"执行了"+x+",余额为："+aLong.addAndGet(x));
lock.unlock();
}
}
结果为：
张三执行了2000,余额为：12000
李四执行了3600,余额为：15600
王二执行了2700,余额为：18300
胖子执行了1300,余额为：19600
麻子执行了600,余额为：20200
小刘执行了800,余额为：21000
此时，加入了一个对象锁，来控制并发访问的控制，不管程序运行多少次，结果都是一样的。有关原子的用法仅仅保证变量操作的原子性，但是需要考虑整个过程的线程安全性。
四、信号量
一个信号量管理很多的许可证，为了获取信号量，线程通过调用acquire请求许可。Java信号量实际上是一个功能完毕的计数器，并由此限制了通过的线程数量，其他线程可以通过调用release释放许可。
它对控制一定资源的消费与回收有着重要意义，信号量常常用于多线程的代码中，并能监控有多少数目的线程等待获取资源，并且通过信号量可以得知可用资源的数目等等，这里强调数目二字，并不是指有哪些在等待，哪些资源可用。例子：
SignalTest.java
package Thread; import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore; public class SignalTest {
public static void main(String[] args){
MyPool myPool=new MyPool(20);
ExecutorService threadPool=Executors.newFixedThreadPool(2);
MyThread_signal t1=new MyThread_signal("任务A",myPool,3);
MyThread_signal t2=new MyThread_signal("任务B",myPool,12);
MyThread_signal t3=new MyThread_signal("任务C",myPool,7);
threadPool.execute(t1);
threadPool.execute(t2);
threadPool.execute(t3);
threadPool.shutdown();
}
}
class MyPool{
private Semaphore sp;//池相关的信号量
MyPool(int size){this.sp=new Semaphore(size);}
public Semaphore getSp(){return sp;}
public void setSp(Semaphore sp){this.sp=sp;}
}
class MyThread_signal extends Thread{
private String name;
private MyPool myPool;
private int x;
MyThread_signal(String name,MyPool myPool,int x){
this.name=name;
this.myPool=myPool;
this.x=x;
}
public void run(){
try{
myPool.getSp().acquire();
System.out.println(name+"成功获取了"+x+"个许可！");
}
catch(InterruptedException e){e.printStackTrace();}
finally{myPool.getSp().release(x);
System.out.println(name+"释放了"+x+"个许可！");}
}
}
结果为：
任务A成功获取了3个许可！
任务A释放了3个许可！
任务C成功获取了7个许可！
任务C释放了7个许可！
任务B成功获取了12个许可！
任务B释放了12个许可！
信号量仅仅是对池资源进行监控，但不能 保证线程的安全，因此，应该自己控制线程的安全访问资源。
五、线程池
线程池的思想还是一种对象池的思想，开辟一块内存空间，里面存放众多的(未死亡)的线程，池中线程执行调度由池管理器来处理。当有线程任务时，从池中取一个，执行完线程对象归池，这样可以避免反复创建线程对象带来的性能开销，节约系统资源。
线程池分为固定尺寸的线程池、可变尺寸线程池。
1、固定大小的线程池
package Thread; import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors; public class Test1 {
public static void main(String[] args){
ExecutorService pool=Executors.newFixedThreadPool(2);
Thread t1=new MyThread_test();
Thread t2=new MyThread_test();
Thread t3=new MyThread_test();
Thread t4=new MyThread_test();
pool.execute(t1);
pool.execute(t2);
pool.execute(t3);
pool.execute(t4);
pool.shutdown();
}
}
class MyThread_test extends Thread{
public void run(){
System.out.println(Thread.currentThread().getName()+"正在执行。。");
}
}
pool-1-thread-1正在执行。。
pool-1-thread-2正在执行。。
pool-1-thread-1正在执行。。
pool-1-thread-2正在执行。。
2、单任务线程池
在上一例修改一行pool对象的代码为：
ExecutorService pool=Executors.newSingleThreadExecutor();
pool-1-thread-1正在执行。。
pool-1-thread-1正在执行。。
pool-1-thread-1正在执行。。
pool-1-thread-1正在执行。。
以上两种情况都是大小固定的，当要加入的池的线程(或任务)超过池最大尺寸的时候，则入此线程池需要排队等待。
3、可变尺寸的线程池
ExecutorService pool=Executors.newCachedThreadPool();
pool-1-thread-1正在执行。。
pool-1-thread-4正在执行。。
pool-1-thread-3正在执行。。
pool-1-thread-2正在执行。。
4、延迟线程池
package Thread; import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit; public class Test1 {
public static void main(String[] args){
//ExecutorService pool=Executors.newFixedThreadPool(2);
//ExecutorService pool=Executors.newSingleThreadExecutor();
//ExecutorService pool=Executors.newCachedThreadPool();
ScheduledExecutorService pool=Executors.newScheduledThreadPool(2);
Thread t1=new MyThread_test();
Thread t2=new MyThread_test();
Thread t3=new MyThread_test();
Thread t4=new MyThread_test();
Thread t5=new MyThread_test();
Thread t6=new MyThread_test();
pool.execute(t1);
pool.execute(t2);
pool.execute(t3);
pool.execute(t4);
pool.schedule(t5,10,TimeUnit.MILLISECONDS);
pool.schedule(t6,10,TimeUnit.MILLISECONDS);
pool.shutdown();
}
}
class MyThread_test extends Thread{
public void run(){
System.out.println(Thread.currentThread().getName()+"正在执行。。");
}
}
pool-1-thread-1正在执行。。
pool-1-thread-2正在执行。。
pool-1-thread-1正在执行。。
pool-1-thread-1正在执行。。
pool-1-thread-2正在执行。。
pool-1-thread-1正在执行。。
5、单任务延迟线程池
在4的代码基础上修改为：
ScheduledExecutorService pool=Executors.newSingleThreadScheduledExecutor();
pool-1-thread-1正在执行。。
pool-1-thread-1正在执行。。
pool-1-thread-1正在执行。。
pool-1-thread-1正在执行。。
pool-1-thread-1正在执行。。
pool-1-thread-1正在执行。。
6、自定义线程池
package Thread; import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit; public class Test1 {
public static void main(String[] args){
//ExecutorService pool=Executors.newFixedThreadPool(2);
//ExecutorService pool=Executors.newSingleThreadExecutor();
//ExecutorService pool=Executors.newCachedThreadPool();
//ScheduledExecutorService pool=Executors.newScheduledThreadPool(2);
//ScheduledExecutorService pool=Executors.newSingleThreadScheduledExecutor();
BlockingQueue<Runnable>bqueue=new ArrayBlockingQueue<Runnable>(20);
ThreadPoolExecutor pool=new ThreadPoolExecutor(2,3,2,TimeUnit.MILLISECONDS,bqueue); Thread t1=new MyThread_test();
Thread t2=new MyThread_test();
Thread t3=new MyThread_test();
Thread t4=new MyThread_test();
Thread t5=new MyThread_test();
Thread t6=new MyThread_test();
pool.execute(t1);
pool.execute(t2);
pool.execute(t3);
pool.execute(t4);
pool.execute(t5);
pool.execute(t6);
// pool.schedule(t5,10,TimeUnit.MILLISECONDS);
//pool.schedule(t6,10,TimeUnit.MILLISECONDS);
pool.shutdown();
}
}
class MyThread_test extends Thread{
public void run(){
System.out.println(Thread.currentThread().getName()+"正在执行。。");
}
}
pool-1-thread-1正在执行。。
pool-1-thread-2正在执行。。
pool-1-thread-1正在执行。。
pool-1-thread-2正在执行。。
pool-1-thread-1正在执行。。
pool-1-thread-2正在执行。。
创建自定义线程池的构造方法很多，本例中的含义如下：
public tThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,BlockingQueue<Runnable>workQueue) 参数
corePoolSize：池中所保存的线程数，包括空闲线程。
maximumPoolSize：池中允许的最大线程数。
keepAliveTime：当线程大于核心时，此为终止前多余的空前线程等待新任务的最长时间。
unit-keepAliveTime：参数的时间单位
workQueue：执行前用于保持任务队列，此队列仅保持有executor方法提交的Runnable任务。 抛出：
IllegalArgumentException：如果corePoolSize或keepAliveTime小于0或者maximumPoolSize小于等于0，或者说corePoolSize大于maximumPoolSize。
NullPointerException：如果workQueue为空
虽然自定义线程池麻烦点，但是可以获取当前线程池的尺寸、正在执行任务的线程数、工作队列等。
六、障碍器
当计算一个大的任务时，常常需要分配好多子任务去执行，只有当所有子任务执行完时，才能执行主任务，这时候需要借助障碍器。
package Thread; import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier; public class CarrierTest {
public static void main(String[] args){
CyclicBarrier cb=new CyclicBarrier(6,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();
}
}
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<99999;i++);//模拟耗时的任务
System.out.println("[子任务"+name+"]开始执行完成了，并通知障碍器已经完成！"); try{
cb.await();//通知障碍器已经完成
}
catch(InterruptedException e){
e.printStackTrace();
}
catch(BrokenBarrierException e){
e.printStackTrace();
}
}
}
[子任务C]开始执行了！
[子任务D]开始执行了！
[子任务E]开始执行了！
[子任务B]开始执行了！
[子任务A]开始执行了！
[子任务B]开始执行完成了，并通知障碍器已经完成！
[子任务E]开始执行完成了，并通知障碍器已经完成！
[子任务D]开始执行完成了，并通知障碍器已经完成！
[子任务F]开始执行了！
[子任务C]开始执行完成了，并通知障碍器已经完成！
[子任务F]开始执行完成了，并通知障碍器已经完成！
[子任务A]开始执行完成了，并通知障碍器已经完成！
>>>>主任务执行了!<<<<
Java线程：条件变量、原子量、线程池等的更多相关文章
- linux 条件变量与线程池
条件变量Condition Variables 概述 1. 条件变量提供了另外一种线程同步的方式.如果没有条件变量,程序需要使用线程连续轮询(可能在临界区critical section内)方式检查条 ...
- conditon_variable(条件变量)用于线程间同步
conditon_variable(条件变量)用于线程间同步 condition_variable有5个函数,函数名及对应的功能如下: wait阻塞自己,等待唤醒 wait_for阻塞自己,等待唤醒, ...
- python线程条件变量Condition（31）
对于线程与线程之间的交互我们在前面的文章已经介绍了 python 互斥锁Lock / python事件Event , 今天继续介绍一种线程交互方式 – 线程条件变量Condition. 一.线程条件变 ...
- java Condition条件变量的通俗易懂解释、基本使用及注意点
最近在看pthread方面的书,看到条件变量一节的时候,回忆了下java中条件变量的使用方式. java中条件变量都实现了java.util.concurrent.locks.Condition接口, ...
- Python学习---线程锁/信号量/条件变量同步/线程池1221
线程锁 问题现象: 多线程情况下,CPU遇到阻塞会进行线程的切换,所以导致执行了tmp-=1的值还未赋值给num=tmp,另一个线程2又开始了tmp -=1,所以导致最后的值重复赋值给了num,所以出 ...
- Linux 线程 条件变量
一:条件变量 直接上最基本的两个函数,先抓主要矛盾: //等待条件 int pthread_cond_wait(pthread_cond_t *restrict cond, pthread_mutex ...
- 四十二、Linux 线程——线程同步之条件变量之线程状态转换
42.1 线程状态转换 42.1.1 状态转换图 42.1.2 一个线程计算,多个线程获取的案例 #include <stdio.h> #include <stdlib.h> ...
- Linux Posix线程条件变量
生产者消费者模型 .多个线程操作全局变量n,需要做成临界区(要加锁--线程锁或者信号量) .调用函数pthread_cond_wait(&g_cond,&g_mutex)让这个线程锁在 ...
- c++ 条件变量
.条件变量创建 静态创建:pthread_cond_t cond=PTHREAD_COND_INITIALIZER; 动态创建:pthread_cond _t cond; pthread_cond_i ...
- (转)Java线程：新特征-条件变量
Java线程:新特征-条件变量 条件变量是Java5线程中很重要的一个概念,顾名思义,条件变量就是表示条件的一种变量.但是必须说明,这里的条件是没有实际含义的,仅仅是个标记而已,并且条件的含义往往 ...
随机推荐
- WebDriver(Selenium2) 常见异常及处理方法
http://uniquepig.iteye.com/blog/1568197 Exception NoSuchElementException Solutions 1. Check the l ...
- hdu 5754 Life Winner Bo 博弈论
对于king:我是套了一个表. 如果起点是P的话,则是后手赢,否则前手赢. 车:也是画图推出来的. 马:也是推出来的,情况如图咯. 对于后:比赛时竟然推错了.QAQ最后看了题解:是个威佐夫博奕.(2, ...
- GPU
GPU主要是进行计算机图形这种大运算量的图形处理器,包括顶点设置.光影.像素操作.对CPU发出的数据和指令,进行着色,材质填充,渲染. 在没有GPU的系统中,3D游戏中物体移动时的坐标转换与光源处理, ...
- php 系列
1.给 跑在windows 环境下的php, 安装redis 拓展.(installing Redis & Redis extension in PHP on XAMPP on windows ...
- java中instanceof的用法
java 中的instanceof 运算符是用来在运行时指出对象是否是特定类的一个实例.instanceof通过返回一个布尔值来指出,这个对象是否是这个特定类或者是它的子类的一个实例. 用法:resu ...
- CodeForces 609B The Best Gift
统计+枚举 #include<cstdio> #include<cmath> #include<cstring> #include<algorithm> ...
- CodeForces 610A Pasha and Stick
#include<cstdio> #include<cstring> #include<cmath> #include<algorithm> using ...
- ecos新命令
创建myapp,在myapp里创建lib/command目录 新建一个文件hello.php <?php /** * myapp_command_hello(myapp->app名称,co ...
- 中国气象台api
1. XML接口 http://flash.weather.com.cn/wmaps/xml/china.xml 这个是全国天气的根节点,列出所有的省,其中的pyName字段是各个省XML的文件名,比 ...
- Unity3D中的函数方法及解释
一.刷新函数 Update 当MonoBehaviour启用时,其Update在每一帧被调用. LateUpdate 当Behaviour启用时,其LateUpdate在每一帧被调用. FixedUp ...