java线程通讯一些简单操作

信号量

什么是信号量（Semaphore）
1.信号量，有时被称为信号灯，是在多线程环境下使用的一种设施, 它负责协调各个线程, 以保证它们能够正确、合理的使用公共资源。
概念
1.信号量对可用许可进行计数，并采取相应的行动。拿到信号量许可的线程可以进入代码，否则就等待。通过申请和释放方法获取和释放访问许可。
2.Semaphore分为单值和多值两种，前者只能被一个线程获得，后者可以被若干个线程获得。
3.Semaphore是用来保护一个或者多个共享资源的访问，一个线程要访问共享资源，先获得信号量，如果信号量的计数器值大于1，意味着有共享资源可以访问，则使其计数器值减去1。如果计数器值为0,线程进入休眠（sleep）。当某个线程使用完共享资源后，释放信号量，并将信号量内部的计数器加1，之前进入休眠的线程将被唤醒。
3.注意，信号灯可以由一个线程使用，然后由另一个线程来进行释放，而锁只能由同一个线程启动和释放，不然就好发生死锁，这一点需要格外注意。
**如何获得Semaphore对象？
public Semaphore(int permits,boolean fair)|| permits:初始化可用的许可数目。
如何返回信号量
public void release() ；
获取当前许可数量
private int nowpermitNum =1;
没有信号量则需要等待唤醒
lock.wait();
唤醒一个等待的线程
lock.notify();

线程池

概念
1.线程池主要用来解决线程生命周期开销问题和资源不足问题。通过对多个任务重复使用线程。
2.通过适当的调整线程中的线程数目可以防止出现资源不足的情况。
3.线程池它可以大大减少线程的创建和销毁次数，提高服务器的工作效率。
线程池的处理流程

实现
1.execute(Runnable)接收一个java.lang.Runnable对象作为参数，并且以异步的方式执行它，使用这种方式没有办法获取执行Runnable之后的结果。
2.submit(Runnable)同样接收一个Runnable的实现作为参数，但是会返回一个Future 对象。这个Future对象可以用于判断Runnable任务是否结束执行。
3.inVokeAny()接收一个包含Callable对象的集合作为参数。调用该方法不会返回Future对象，而是返回集合中某个Callable对象的结果。

class ExecutorThread extends Thread {
	boolean runningFlag = false;
	private Runnable callBack = null;
	public void setCallBack(Runnable callBack) {
		this.callBack = callBack;
	}
	public synchronized void setRunning(boolean flag) {
		runningFlag = flag;
		if (flag)
		this.notify();
	}
	public synchronized void run() {
		try {
		while (true) {
		if (!runningFlag) {
		this.wait();
	} else {
		callBack.run();
		setRunning(false);
	}
}
	} catch (Exception e) {}
}


public class ThreadPoolExecutor {
	private List<ExecutorThread> threads;
	public ThreadPoolExecutor(int threadCount) {		
threads = Collections.synchronizedList(new ArrayList<ExecutorThread>());
	for (int i = 1; i <= threadCount; i++) {
		ExecutorThread thread = new ExecutorThread();
		threads.add(thread);
		thread.start();
	}
}
	public void execute(Runnable callBack) {
		int i;
		for (i = 0; i < threads.size(); i++) {
		ExecutorThread currentThread = threads.get(i);
		if (!currentThread.runningFlag) {
		currentThread.setCallBack(callBack);
		currentThread.setRunning(true);
		return;
	}
}
	if (i == threads.size()) {
	System.out.println("线程资源已经用完，请稍等片刻再申请资源。");
		}
	}
}

Lock接口及重入锁

概念
1.Lock接口，是对控制并发的工具的抽象。它比使用synchronized关键词更灵活，并且能够支持条件变量。它是一种控制并发的工具，一般来说，它控制对某种共享资源的独占。
2.Java中接口的实现只给了ReentrantLock这一个默认的实现，也就是重入锁，它的概念是在获得锁后可以重复获得该资源的锁，
3.synchronized关键字：当synchronized修饰的是方法时，synchronized所拿到的是调用该方法的对象的锁。
（2）当synchronized()修饰的同步代码块时，synchronized拿到的是指定对象的锁。
实现
1.void lock()：获取锁。当锁不可用时，调用线程会被强制一直等待直到锁可用。
2.void lockInterruptibly()：除非调用线程被中断，否则获得锁。
3.boolean tryLock()：在该方法被调用时，锁可用则获得锁，当获得锁之后，该方法返回true；反之返回false。
4.void unlock()：释放锁
重入锁
1.如果锁具备可重入性，则称作为可重入锁。像synchronized和ReentrantLock都是可重入锁。
2.可重入锁与普通锁的目的： 保证线程访问时的线程安全
可重入锁可以避免线程死锁
3. synchronized 和 ReentrantLock 都是可重入锁 。
4. 子类锁与父类锁的重入： 子类覆写了父类的synchonized方法，然后调用父类中的方法， 此时如果没有重入的锁，那么这段代码将产生死锁。
不可重入锁：
当调用print()方法时，获得了锁，这时就无法再调用doAdd()方法，这时必须先释放锁才能调用，所以称这种锁为不可重入锁

public class Count{
      Lock lock = new Lock();
     public void print(){
         lock.lock();
         doAdd();
         lock.unlock();
     }
     public void doAdd(){
         lock.lock();
        //do something
        lock.unlock();
    }
 }		

可重入锁：

public class Lock{
    boolean isLocked = false;
    Thread  lockedBy = null;
    int lockedCount = 0;
    public synchronized void lock()
            throws InterruptedException{
        Thread thread = Thread.currentThread();
        while(isLocked && lockedBy != thread){
            wait();
        }
        isLocked = true;
        lockedCount++;
        lockedBy = thread;
    }
    public synchronized void unlock(){
        if(Thread.currentThread() == this.lockedBy){
            lockedCount--;
            if(lockedCount == 0){
                isLocked = false;
                notify();
            }
        }
    }
}

ThreadLocal

概念
1.ThreadLocal的实例代表了一个线程局部的变量，每条线程都只能看到自己的值，解决多线程中相同变量的访问冲突问题。
实现
1.ThreadLocal.get: 获取ThreadLocal中当前线程变量的值。
2.ThreadLocal.set: 设置ThreadLocal中当前线程变量的值
3.ThreadLocal.remove: 移除ThreadLocal中当前线程变量的值。
4.ThreadLocal.initialValue: ThreadLocal没有被当前线程赋值时或当前线程刚调用remove方法后调用get方法，返回此方法值。
5.Thread.currentThread：获取当前线程。
6.每个Thread的对象都有一个ThreadLocalMap，当创建一个ThreadLocal的时候，就会将该ThreadLocal对象添加到该Map中
7.　对于每一个ThreadLocal对象，都有一个final修饰的int型的threadLocalHashCode不可变属性.
创建了两个线程，然后线程对各自的局部变量进行递增的操作。每个线程中的局部变量的初始值都是100。

class Bank{
ThreadLocal<Integer> t =new ThreadLocal<>(){
protected Integer initiaValue(){
return  100;
	}
};
	public int get(){
	return t.get();
}
	public void set(){
	t.set(t.get()+10);
	}
}

对ThreadLocal的操作，也就是在原来的基础上进行加10的操作，然后打印出结果。

class Tansfer implement Runable{
	Bank  bank;
	public Transfer (Bank bank){
	this.bank =bank;
}
	public void run(){
	for(int i=0;i<10;i++){
	system.out println(Thread.currentThread()+""+get());
	}
}
}

原子操作类

概念
原子操作类相当于泛化的volatile变量，能够支持原子读取-修改-写操作。比如AtomicInteger表示一个int类型的数值，提供了get和set方法，这些volatile类型的变量在读取与写入上有着相同的内存语义。
原子操作类的更新三种方式：
原子更新布尔变量：AtomicBoolean
原子更新整型变量：AtomicInteger
原子更新长整型变量：AtomicLong
通过原子类更新数组中的某个元素：
原子更新整型数组：AtomicIntegerArray
原子更新长整型数组：AtomicLongArray
原子更新引用类型数组：AtomicReferenceArray
原子更新字段，需要两个步骤
1.每次必须使用newUpdater创建一个更新器，并且需要设置想要更新的类的字段
2.更新类的字段（属性）必须为public volatile

生产者-消费者模式

概念
1.某个模块负责产生数据，这些数据由另一个模块来负责处理。产生数据的模块，就形象地称为生产者；而处理数据的模块，就称为消费者。
2.在生产者与消费者之间在加个缓冲区，我们形象的称之为仓库，生产者负责往仓库了进商品。
3.而消费者负责从仓库里拿商品，这就构成了生产者消费者模式。

生产者-消费者模式遵循的模式
1.生产者仅仅在仓储未满时候生产，仓满则停止生产
2.消费者仅仅在仓储有产品时候才能消费，仓空则等待
3.当消费者发现仓储没产品可消费时候会通知生产者生产
4.生产者在生产出可消费产品时候，应该通知等待的消费者去消费