BlogJava-nod0620-文章分类-多线程

java 线程池

nod0620 — Tue, 20 Sep 2011 14:27:00 GMT

摘要: 图左边是线程池的类结构，右边是放入线程池执行的任务类结构ExecutorServiceExecutorService定义了线程池的基本的方法，AbstractExecutorService是个抽象类，实现了ExecutorService的部分，主要是实现了几个submit()方法，并且提供方法将提交进来的任务封装成FutureTask,ThreadPoolExecutor则实现线程池的管理Futu... 阅读全文

nod0620 2011-09-20 22:27 发表评论

java thread 之Lock

nod0620 — Sat, 17 Sep 2011 16:12:00 GMT

concurrent包里面有很多Lock的具体实现，其具体的实现都是基于AQS实现的

ReentrantLock
ReentrantLock是可重入的互斥锁，重点是重入和互斥，ReentrantLock 将由最近成功获得锁的线程所持有，当这个线程再次尝试拥有这个Lock时就是重入。互斥就是
在某一时间只有一个线程能持有Lock。
    public void lock() {
        sync.lock();
    }
获得锁方法，Sync是AQS的抽象子类，实现可重入和互斥的大部分功能。在Sync的子类中有FairSync和NonfairSync两种代表公平锁策略和非公平锁策略

Sync lock方法留给子类去实现，NonfairSync的实现：
        final void lock() {
            if (compareAndSetState(0, 1))
                setExclusiveOwnerThread(Thread.currentThread());
            else
                acquire(1);
        }
不管是不是有其他线程在AQS的阻塞的队列里面，如果当前线程能获得线程，就直接获得线程，不行的话执行AQS的acquire()方法，基本就是进入阻塞队列的命了。
关键点:AQS的acquire()中调用的tryAcquire(int arg)是留给子类实现的，是在进入阻塞队列前再尝试一次获取锁(lock()方法到这个点上面可能其他线程已经释放锁)

NonfairSync的tryAcquire(int arg)调用的nonfairTryAcquire()实现:
        final boolean nonfairTryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) {//关键点1
                if (compareAndSetState(0, acquires)) {
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            else if (current == getExclusiveOwnerThread()) {
                int nextc = c + acquires;//关键点2
                if (nextc < 0) // overflow
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            return false;
        }
关键点1：state为0，没有线程请求锁，直接分配给本线程
关键点2. 如果本线程已经得到锁，state加1，即重入。

FairSync的实现:
    final void lock() {
            acquire(1);//关键点1
        }
    protected final boolean tryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) {
                if (isFirst(current) && //关键点2
                    compareAndSetState(0, acquires)) {
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            else if (current == getExclusiveOwnerThread()) {
                int nextc = c + acquires;
                if (nextc < 0)
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            return false;
        }
关键点1：公平策略，没有给当前线程优惠
关键点2：判断当前线程有没有在阻塞队列的第一位，没在第一位不往下继续执行，这样先给阻塞队列的线程机会，这样做速度比较慢，吞吐量比较小

    public boolean tryLock() {
        return sync.nonfairTryAcquire(1);
    }
tryLock尝试获得锁，不能获得话就直接返回，没有公平策略一说。

unlock
    public void unlock() {
        sync.release(1);
    }

    public final boolean release(int arg) {
        if (tryRelease(arg)) {
            Node h = head;
            if (h != null && h.waitStatus != 0)
                unparkSuccessor(h);
            return true;
        }
        return false;
    }
tryRelease()留给AQS子类执行：
        protected final boolean tryRelease(int releases) {
            int c = getState() - releases;
            if (Thread.currentThread() != getExclusiveOwnerThread())
                throw new IllegalMonitorStateException();
            boolean free = false;
            if (c == 0) {
                free = true;
                setExclusiveOwnerThread(null);
            }
            setState(c);
            return free;
        }
如果state被减后还不为0，表示这个锁被一个线程重入后还没有完全释放，release()方法后面不会执行，也就是不会执行unpark阻塞队列中的线程.

ReentrantReadWriteLock
ReentrantReadWriteLock内部有两个锁：互斥可重入的WriteLock和共享的ReadLock
内部实现中state字段的高16位代表的是read count，低16位代表的是write count
AQS的实现也有NonfairSync和FairSync之分：
主要区别是同时有读写线程时候对待读写线程策略不同。
NonfairSync:
final boolean writerShouldBlock(Thread current) {
            return false; // writers can always barge
        }
        final boolean readerShouldBlock(Thread current) {
            /* As a heuristic to avoid indefinite writer starvation,
             * block if the thread that momentarily appears to be head
             * of queue, if one exists, is a waiting writer. This is
             * only a probablistic effect since a new reader will not
             * block if there is a waiting writer behind other enabled
             * readers that have not yet drained from the queue.
             */
            return apparentlyFirstQueuedIsExclusive();
        }
write永远都不阻塞，read的话看阻塞队列header之后的node是不是write的，如果是就阻塞，可以避免read一直运行导致的write饥饿。
FairSync：
      final boolean writerShouldBlock(Thread current) {
            // only proceed if queue is empty or current thread at head
            return !isFirst(current);
        }
        final boolean readerShouldBlock(Thread current) {
            // only proceed if queue is empty or current thread at head
            return !isFirst(current);
        }
write和read都有判断是不是阻塞队列header后的第一个node。

对于ReadLock
     public void lock() {
            sync.acquireShared(1);
        }
调用AQS的acquireShared()，其中会执行留给AQS子类实现的tryAcquireShared():
protected final int tryAcquireShared(int unused) {
            /*
             * Walkthrough:
             * 1. If write lock held by another thread, fail
             * 2. If count saturated, throw error
             * 3. Otherwise, this thread is eligible for
             *    lock wrt state, so ask if it should block
             *    because of queue policy. If not, try
             *    to grant by CASing state and updating count.
             *    Note that step does not check for reentrant
             *    acquires, which is postponed to full version
             *    to avoid having to check hold count in
             *    the more typical non-reentrant case.
             * 4. If step 3 fails either because thread
             *    apparently not eligible or CAS fails,
             *    chain to version with full retry loop.
             */
            Thread current = Thread.currentThread();
            int c = getState();
            if (exclusiveCount(c) != 0 &&
                getExclusiveOwnerThread() != current)
                return -1;
            if (sharedCount(c) == MAX_COUNT)
                throw new Error("Maximum lock count exceeded");
            if (!readerShouldBlock(current) &&
                compareAndSetState(c, c + SHARED_UNIT)) {
                HoldCounter rh = cachedHoldCounter;
                if (rh == null || rh.tid != current.getId())
                    cachedHoldCounter = rh = readHolds.get();
                rh.count++;
                return 1;
            }
            return fullTryAcquireShared(current);
        }
策略是以下的几点：
1.如果当前write持有锁，直接返回-1.
2.没有write持有锁，判断是否需要阻塞读请求，之后原子更新read count
3.上面成功后就返回1，不成功的话在循环中试着读取：
     final int fullTryAcquireShared(Thread current) {
            /*
             * This code is in part redundant with that in
             * tryAcquireShared but is simpler overall by not
             * complicating tryAcquireShared with interactions between
             * retries and lazily reading hold counts.
             */
            HoldCounter rh = cachedHoldCounter;
            if (rh == null || rh.tid != current.getId())
                rh = readHolds.get();
            for (;;) {
                int c = getState();
                int w = exclusiveCount(c);
                if ((w != 0 && getExclusiveOwnerThread() != current) ||
                    ((rh.count | w) == 0 && readerShouldBlock(current)))
                    return -1;
                if (sharedCount(c) == MAX_COUNT)
                    throw new Error("Maximum lock count exceeded");
                if (compareAndSetState(c, c + SHARED_UNIT)) {
                    cachedHoldCounter = rh; // cache for release
                    rh.count++;
                    return 1;
                }
            }
        }
unLock方法就是将read count 减1，然后查看阻塞队列有没有线程需要unpark

WriteLock的实现和ReetrantLock的实现是一致的
Semaphore
Semaphore是信号量的概念，主要控制同一时间内对访问资源的线程数的控制。底层实现是AQS的
acquireShared()和releaseShared().

CountDownLatch
CountDownLatch在完成一组正在其他线程中执行的操作之前，允许线程等待直到他们完成操作
await()方法一直等到state=0，初始时CountDownLatch初始化state为传入的数值，一个线程
执行操作完成的话执行countDown()方法将state减1，直到为0，await()方法不再阻塞。

CyclicBarrier
当一组线程调用CyclicBarrier.await()方法，就会阻塞在那里，当最后一个线程进入调用此方法时，就执行
一个公共的Runnable.原理是：初始化时有count属性，当前面count-1个线程到来都condition.await()，第count个
线程来就执行公共Runnable，然后执行condition.signAll()方法来使得其他线程从阻塞中解脱出来.

nod0620 2011-09-18 00:12 发表评论

java thread 之AQS

nod0620 — Thu, 15 Sep 2011 14:57:00 GMT

摘要: JDK1.5引入了Doug Lea大神的concurrent框架，其中AbstractQueuedSynchronizer是concurrent框架的基本，从大神的paper中可以看到1.传统的synchronized不能进行中段，这个不合适2.如果将concurrent重心放在少数竞争下优化锁，而在其他情况下放任缓慢执行的策略是不正确的3.需要可预测的维护效率，即使在同步竞争激烈的情况下，理想中... 阅读全文

nod0620 2011-09-15 22:57 发表评论

并发程序的性能思考

nod0620 — Fri, 13 Aug 2010 15:10:00 GMT

首先说下线程的死锁，个人想法（从艺术家吃饭说起）：
1.必须有资源想被多个线程独占，但是资源不能共享，也就是一次只能一个线程用
2.一个线程抢占一个资源然后再等待另外一个线程（大家都这样）
3.资源不能被强占，大家都是优先级相同的线程，都在那里等
4.发生循环等待了（多个锁）
避免死锁就是打破上面任何一条

    一个并发程序好坏大致需要两个方面：响应速度和伸缩性，也即是有多快和有多少，这往往是相互矛盾的两方面，我们需要做的就是平衡这两方面。
    从并发程序的特点看，我们可以从以下几方面入手性能的优化：
    1 多线程执行那么必须在多个线程里面上下切换，这需要操作系统保存上个线程的多线程，创建或者唤醒下个线程，这个都消耗资源。所以减少上下文切换，可以增加伸缩性（多几个线程执行）
    2 synchronized同步块，同步块意味着这个里面是单线程执行的，既是串行执行，其中synchronized保持了内存的可见性和原子性，volatile保证了可见性，这都使得线程的工作内存的内容每一次都要交换到主内存中，这样的话工作内存的缓存失效，所以尽量的缩小同步，也可以使用concurrent包的lock显示锁定。
   3 阻塞，这个看看io和nio就知道了，可以将阻塞的操作移除出我们主要的线程，另外起线程处理
   4 锁，这个在并发中很重要，可以减小持有的锁的时间（尽量的缩小同步块等），减少对锁的占用时间，比如拆分锁，读写分离锁，或者是分成好几个锁（concurrenthashmap），把独占锁分成多个锁
   5 线程池管理线程的创建和生命周期，减少创建和销毁线程的消耗
   6.不可变对象，抛弃一切的同步

最重要的是在这之前我们需要审视我的环境：cpu，网络，i/0，数据库等等

nod0620 2010-08-13 23:10 发表评论

Read—Write Lock Pattern

nod0620 — Wed, 11 Aug 2010 14:31:00 GMT

Read—Write Lock Pattern将读写分离，在读取之前，获得用来读取的锁，在写在之前，获得用来写入的锁，
读写的锁的关系是：有人读取（多个也无所谓）时，写不能进行；有人写入时，其他的写和读不能进行。

代码如下：

package readwritelock;

public class Data {

    private final char[] buffer;
    private final ReadWriteLock readWriteLock = new ReadWriteLock();

    public Data(int size){
        this.buffer=new char[size];
        for (int i = 0; i < buffer.length; i++) {
            buffer[i] ='*';
        }
    }

    public char[]  read(){
        readWriteLock.readLock();
        try{
            return doRead();
        }finally{
            readWriteLock.readUnLock();
        }
    }

    public void write(char c){
        readWriteLock.writeLock();
        try{
            doWrite(c);
        }finally{
            readWriteLock.writeUnLock();
        }
    }

    private char[] doRead(){
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return buffer;
    }

    private void doWrite(char c){
        for (int i = 0; i < buffer.length; i++) {
            buffer[i] =c;
        }
    }


}
/*******************************************/
package readwritelock;

public class ReadThread extends Thread {
    private Data data;

    public ReadThread(Data data) {
        this.data = data;
    }

    public void run() {
        while (true) {
            char[] c = data.read();
            System.out.println(Thread.currentThread().getName() + ": "
                    + String.valueOf(c));
        }
    }
}
/*******************************************/
package readwritelock;

public class ReadWriteLock {
    private volatile int readLocks = 0;
    private volatile int writeLocks = 0;
    private volatile int waitLocks = 0;

    private volatile boolean writeFirst =true;

    public synchronized void readLock() {
        // 写锁或者等待锁大于0，读阻塞
        while (writeLocks > 0 || writeFirst&&waitLocks > 0) {
            try {
                wait();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        readLocks++;
    }

    public synchronized void readUnLock() {
        readLocks--;
        writeFirst =true;
        notifyAll();
    }

    public synchronized void writeLock() {
        // 写等待
        waitLocks++;
        try {
            while (readLocks > 0||writeLocks>0) {
                wait();
            }
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally{
            waitLocks --;
        }
        writeLocks++;
    }
    public synchronized void writeUnLock() {
        writeLocks--;
        writeFirst =false;
        notifyAll();
    }
}
/*********************************************/
package readwritelock;

import java.util.Random;

public class WriterThread extends Thread {

    private Data data;
    private String str;
    private int index =0;
    public WriterThread(Data data, String str) {
        this.data = data;
        this.str = str;
    }
    public void run(){
        while(true){
            data.write(get());
            try {
                Thread.sleep(new Random().nextInt(200));
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }

    private char get(){
        char a =str.charAt(index);
        index++;
        if(index>=str.length()){
            index = 0;
        }
        return a;
    }
}
/*********************************************/
package readwritelock;

public class Test {
public static void main(String[] args) {
    Data data = new Data(10);
    new WriterThread(data, "asdsad");
    new WriterThread(data, "有亲戚吗");
    new ReadThread(data).start();


}
}

jdk concurrent 包里面有CurrentHashMap和CopyOnWriteArrayList都有锁的概念
CurrentHashMap有个分离锁，把Map分成几个段，对于一个段的写入，不影响其他段的读写，
CopyOnWriteArrayList可以并发的读取，并且返回一个稳定的迭代器，对于写入，是重新开辟一个数组，拷贝原来的数据进行修改，修改完成后再合并回去.
jdk concurrent的 ReentrantReadWriteLock就是一个可以冲入的读写锁

nod0620 2010-08-11 22:31 发表评论

guarded suspension pattern和productor-consumer pattern

nod0620 — Sat, 07 Aug 2010 17:32:00 GMT

请求发出以后，如果没有准备好的一直等待到数据准备好在返回---》谨慎的等待（恶心的名字）

package guarded;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

public class Data {

    private BlockingQueue<String>  blockingQueue = new ArrayBlockingQueue<String>(1);

    public void putRequest(String content){
        try {
            blockingQueue.put(content);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    public String getRequest(){
        try {
            return blockingQueue.take();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return "";
    }
}
/*******************************************/

package guarded;

import java.util.Random;

public class ClientThread extends Thread{
    private Data data;

    public ClientThread(Data data){
        this.data =data;
    }
    public void run(){
        for (int i = 0; i < 1000; i++) {
            System.out.println("put content:"+i);
            data.putRequest(String.valueOf(i));
            try {
                Thread.sleep(new Random().nextInt(1000));
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
}
/***********************************/

package guarded;

import java.util.Random;

public class ServerThread extends Thread {
    private Data data;

    public ServerThread(Data data){
        this.data =data;
    }

    public void run(){
        while(true){
            System.out.println("get content:"+data.getRequest());
            try {
                Thread.sleep(new Random().nextInt(1000));
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
}
/**********************************/
package guarded;

public class Test {

    /**
     * @param args
     */
    public static void main(String[] args) {
        Data data = new Data();
        new ServerThread(data).start();
        new ClientThread(data).start();
    }

}

guarded suspension pattern和productor-comsumer(生产者消费者)很像，这里Data的blockingQueue的容量是1，productor-comsumer则大于一，productor-comsumer也基本上是多对多关系。
jdk1.4以前主要用wait（），notifyAll（）进行控制，现在用BlockingQueue更加简单

参与者：
Data（存放资源和等待条件等一系列条件和业务处理的类） ServerThread和ClientThread（处理结果和请求发起的线程）

nod0620 2010-08-08 01:32 发表评论

single thread execution

nod0620 — Sat, 07 Aug 2010 16:16:00 GMT

single thread execution主要思想是：在同一时刻，对于某一共享资源，只能有一个人访问，即资源同步。

package gate;

public class Person {
    private String name;
    private String address;

    public synchronized void  setNameAddress(String name,String address){
        this.name = name;
        this.address = address;
        check();
    }
    private  void check(){
        if(!name.equals(address)){
            System.out.println("problem:"+name+","+address);
        }

    }
}

/*****************************/

package gate;

public class RunThread extends Thread {
    private Person person;
    private String name;
    private String address;
    public RunThread(Person person,String name,String address){
        this.person =person;
        this.name  =name;
        this.address  =address;
    }

    public  void run(){
        while(true){
            person.setNameAddress(name,address);

        }
    }

}
/*******************************/
package gate;

public class Test {
    public static void main(String[] args) {
        Person person = new Person();
        new RunThread(person,"345","345").start();

        new RunThread(person,"456","456").start();

    }
}

参与者如下：
共享资源（Person ），资源利用者（RunThread）
对于共享资源中的线程非安全方法需要加入锁机制(synchronized或者ReentrantLock)进行同步，确保在某个时间点只有一个线程在访问该方法。
适应的时机：
多线程环境（废话），资源共享（又是废话），资源的状态发生变化（状态不会变化的对象线程安全的）

nod0620 2010-08-08 00:16 发表评论