Monitor Directory and File(IV)Multi Threads

Monitor Directory and File(IV)Multi Threads

1. Lock - Free
simple lock and free

package com.xxxxxxx.importdata.filemonitor.multithreads;
import java.util.concurrent.atomic.AtomicInteger;
public class Counter
{
private AtomicInteger max = new AtomicInteger();
public void set(int value)
{
// step 1 loop
for (;;)
{
int current = max.get();
if (value > current)
{
// CAS compare and set
if (max.compareAndSet(current, value))
{
// break
break;
}
else
{
continue;
}
}
else
{
// break
break;
}
}
}
public int getMax()
{
return max.get();
}
}

Lock and Free in BeanManager
class BeanManager {
private ConcurrentMap<String, Object> map = new ConcurrentHashMap<String, Object>();
public Object getBean(String key) {
Object bean = map.get(key);
if (bean == null) {
map.putIfAbsent(key, createBean());
bean = map.get(key);
}
return bean;
}
}

CopyOnWriteArrayList
class Engine {
private List<Listener> listeners = new CopyOnWriteArrayList <Listener>();
public boolean addListener(Listener listener) {
return listeners.add(listener);
}
public void doXXX() {
for (Listener listener : listeners) {
listener.handle();
}
}
}

2. CoutDownLatch
Waiting for all the sub threads finished, the main thread continous.
package com.xxxxxx.importdata.filemonitor.multithreads;
import java.util.concurrent.CountDownLatch;
public class WaitingEndCoutDownLatchExecutor
{
public static void main(String[] args) throws InterruptedException
{
final int COUNT = 4;
final CountDownLatch completeLatch = new CountDownLatch(COUNT);
for (int i = 0; i < COUNT; ++i)
{
Thread thread = new Thread("worker thread " + i) {
public void run()
{
System.out.println("execute thread = " + Thread.currentThread().getName());
completeLatch.countDown();
}
};
thread.start();
}
completeLatch.await();
System.out.println("All threads finished!");
}
}

the result of console is:
execute thread = worker thread 0
execute thread = worker thread 2
execute thread = worker thread 1
execute thread = worker thread 3
All threads finished!

Start all the sub threads at the same time
package com.xxxxxx.importdata.filemonitor.multithreads;
import java.util.concurrent.CountDownLatch;
public class StartAfterSignalCoutDownLatchExecutor
{
public static void main(String[] args) throws InterruptedException
{
final CountDownLatch startLatch = new CountDownLatch(1);
for (int i = 0; i < 4; ++i)
{
Thread thread = new Thread("worker thread " + i) {
public void run()
{
try
{
startLatch.await();
}
catch (InterruptedException e)
{
return;
}
System.out.println("execute thread = " + Thread.currentThread().getName());
}
};
thread.start();
}
System.out.println("Let's start: ");
startLatch.countDown();
}
}

The result of the console is:
Let's begin:
execute thread = worker thread 0
execute thread = worker thread 2
execute thread = worker thread 1
execute thread = worker thread 3

3. CycliBarrier
When all the points reach, the system will go on.

package com.xxxxxx.importdata.filemonitor.multithreads;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
public class CycliBarrierPerformanceRunner
{
private int threadCount;
private CyclicBarrier barrier;
private int loopCount = 2;
public CycliBarrierPerformanceRunner(int threadCount)
{
this.threadCount = threadCount;
barrier = new CyclicBarrier(threadCount, new Runnable() {
public void run()
{
collectTestResult();
}
});
for (int i = 0; i < threadCount; ++i)
{
Thread thread = new Thread("test-thread " + i) {
public void run()
{
for (int j = 0; j < loopCount; ++j)
{
doTest();
try
{
barrier.await();
}
catch (InterruptedException e)
{
return;
}
catch (BrokenBarrierException e)
{
return;
}
}
}
};
thread.start();
}
}
private void doTest()
{
System.out.println("executing thread = " + Thread.currentThread().getName());
}
private void collectTestResult()
{
System.out.println("Result thread = " + Thread.currentThread().getName());
}
public static void main(String[] args)
{
new CycliBarrierPerformanceRunner(3);
}
}

the result of the console is:
executing thread = test-thread 0
executing thread = test-thread 2
executing thread = test-thread 1
Result thread = test-thread 2
executing thread = test-thread 2
executing thread = test-thread 0
executing thread = test-thread 1
Result thread = test-thread 1

4. ScheduledExecutorService
schedule(Runnable command, long delay, TimeUnit unit) : ScheduledFuture
schedule(Callable<V> callable, long delay, TimeUnit unit) : ScheduledFuture
scheduleAtFixedRate(Runnable comand, long initDelay, long period, TimeUnit unit) : ScheduledFuture
scheduleWithFixedDelay(Runnable command, long initDelay, long delay, TimeUnit unit) : ScheduledFuture

package com.xxxxxxx.importdata.filemonitor.multithreads;

import java.util.TimerTask;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;
public class ScheduledExecutorServiceRunner
{
public static void main(String[] args) throws InterruptedException, ExecutionException
{
ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(10);
SimpleTask task = new SimpleTask();
ScheduledFuture<?> future = scheduler.schedule(task, 1, TimeUnit.SECONDS);
// future.get();
// future.cancel(false);
scheduler.schedule(task, 2, TimeUnit.SECONDS);
scheduler.scheduleAtFixedRate(task, 2, 3, TimeUnit.SECONDS);
}
private static class SimpleTask extends TimerTask
{
public void run()
{
System.out.println("Task is running!");
}
}
}

references:
http://www.cnblogs.com/jobs