Monitor Directories and File(III)Multi Threads

Monitor Directories and File(III)Multi Threads

Reading a book named shaojinwensj recently and learn a lot from him.
1. Basic ideas
If we want to start a thread, we need to give it a name.

We need to do something if the thread interrupted
If(Thread.interrupted()){
break;
}

try{
doSomething();
}catch(InterruptedException e){
break;
}

if(Thread.interrupted()){
throw new InterruptedException();
}

ThreadLocal<T>
initialValue
set
get
remove

2. Executors
java.util.concurrent.Executors is the factory class of Executor.
TaskOne.java:
package com.xxxxx.importdata.filemonitor.multithreads;
import java.util.concurrent.Callable;
public class TaskOne implements Callable<Object>
{
public Object call() throws Exception
{
System.out.println("TaskOne is called!");
return true;
}
}
TaskTwo.java:
package com.xxxxxx.importdata.filemonitor.multithreads;
public class TaskTwo implements Runnable
{
public void run()
{
System.out.println("TaskTwo is called!");
}
}
SingleExecutor.java:
package com.xxxxx.importdata.filemonitor.multithreads;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
public class SingleExecutor
{
public static void main(String[] args) throws InterruptedException, ExecutionException, TimeoutException
{
TaskOne taskOne = new TaskOne();
TaskTwo taskTwo = new TaskTwo();
ExecutorService executor = Executors.newSingleThreadExecutor();
Future<Object> future1 = executor.submit(taskOne);
future1.get();
Future<?> future2 = executor.submit(taskTwo);
future2.get(3, TimeUnit.SECONDS);
}
}

3. Blocking Queue
blockingQ.put(object) block when queue is full------producer
blockingQ.take() block when queue is empty ---------consumer

ArrayBlockingQueue
LinkedBlockingQueue
SynchronousQueue

Queue<E>
add
offer
remove
poll
element
peek

BlockingQueue<E>
put
take
drainTo(Collection)

we will use put and take, better to use drainTo.

Object object = blockingQ.poll(); //not right
Object object = blockingQ.take(); // right
Object object = blockingQ.poll(1,TimeUnit.SECONDS); // right

A simple BlockingQ implementation

package com.xxxxxx.importdata.filemonitor.multithreads;
import java.util.LinkedList;
import java.util.Queue;
public class BlockingQ
{
private Object notEmpty = new Object();
private Object notFull = new Object();
private Queue<Object> linkedList = new LinkedList<Object>();
private int maxLength = 10;
public Object take() throws InterruptedException
{
synchronized (notEmpty)
{
if (linkedList.size() == 0)
{
notEmpty.wait();
}
synchronized (notFull)
{
if (linkedList.size() == maxLength)
{
notFull.notifyAll();
}
return linkedList.poll();
}
}
}
public void offer(Object object) throws InterruptedException
{
synchronized (notEmpty)
{
if (linkedList.size() == 0)
{
notEmpty.notifyAll();
}
synchronized (notFull)
{
if (linkedList.size() == maxLength)
{
notFull.wait();
}
linkedList.add(object);
}
}
}
}

A lock and condition BlockingQueue
package com.xxxxx.importdata.filemonitor.multithreads;
import java.util.LinkedList;
import java.util.Queue;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class BlockingQ
{
private Lock lock = new ReentrantLock();
private Condition notEmpty = lock.newCondition();
private Condition notFull = lock.newCondition();
private Queue<Object> linkedList = new LinkedList<Object>();
private int maxLength = 10;
public Object take() throws InterruptedException
{
lock.lock();
try
{
if (linkedList.size() == 0)
{
notEmpty.await();
}
if (linkedList.size() == maxLength)
{
notFull.signalAll();
}
return linkedList.poll();
}
finally
{
lock.unlock();
}
}
public void offer(Object object) throws InterruptedException
{
lock.lock();
try
{
if (linkedList.size() == 0)
{
notEmpty.signalAll();
}
if (linkedList.size() == maxLength)
{
notFull.await();
}
linkedList.add(object);
}
finally
{
lock.unlock();
}
}
}

4. ReentrantLock and Synchronized
Synchronized is a simple Lock, one common Lock will have multi Conditions, but synchronized will be one Lock and
one Condition.

Lock -----> lock(); unlock();
Condition -----> await();signal();signalAll()
synchronized ---> lock();unlock();wait();notify();notifyAll();

Atomic
AtomicInteger
AtomicBoolean
AtomicLong
AtomicReference

references:
CountDownLatch
http://www.iteye.com/topic/1002652
http://www.iteye.com/topic/869109
http://www.iteye.com/topic/581476
CyclicBarrier
http://www.iteye.com/topic/657295
http://www.iteye.com/topic/363625
http://www.iteye.com/topic/713053
Pools
http://w2c2y2.iteye.com/blog/479672
http://www.cnblogs.com/jobs