package com.thread.concurrent;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
public class CirticalSection
{
// Test the two different approaches :
static void testApproaches(PairManager pman1, PairManager pman2)
{
ExecutorService exec = Executors.newCachedThreadPool();
PairManipulartor pm1 = new PairManipulartor(pman1), pm2 = new PairManipulartor(pman2);
PairChecker pcheck1 = new PairChecker(pman1), pcheck2 = new PairChecker(pman2);
exec.execute(pm1);
exec.execute(pm2);
exec.execute(pcheck1);
exec.execute(pcheck2);
try
{
TimeUnit.MILLISECONDS.sleep(500);
}
catch (InterruptedException e)
{
System.out.println("sleep interrupted");
}
System.out.println("pm1 : " + pm1 + "\n pm2 :" + pm2);
System.exit(0);
}
public static void main(String[] args)
{
PairManager pman1 = new PairManager1(), pman2 = new PairManager2();
testApproaches(pman1, pman2);
}
}
class Pair
{
// Not thread-safe
private int x;
private int y;
public Pair(int x, int y)
{
this.x = x;
this.y = y;
}
public Pair()
{
this(0, 0);
}
public int getX()
{
return x;
}
public void incrementX()
{
x++;
}
public int getY()
{
return y;
}
public void incrementY()
{
y++;
}
@Override
public String toString()
{
return "pair [x=" + x + ", y=" + y + "]";
}
public class PairValuesNotEqualException extends RuntimeException
{
public PairValuesNotEqualException()
{
super("Pair values not equal : " + Pair.this);
}
}
// Arbitrary invariant -- both variables must be equal:
public void checkState()
{
if (x != y)
throw new PairValuesNotEqualException();
}
}
// Protect a pair inside a thread-safe class:
abstract class PairManager
{
AtomicInteger checkCounter = new AtomicInteger(0);
protected Pair p = new Pair();
private List<Pair> storage = Collections.synchronizedList(new ArrayList<Pair>());
public synchronized Pair getPair()
{
// Make a copy to keep the original safe
return new Pair(p.getX(), p.getY());
}
// Assume this is a time consuming operation
protected void store(Pair p)
{
storage.add(p);
try
{
TimeUnit.MILLISECONDS.sleep(50);
}
catch (InterruptedException e)
{
e.printStackTrace();
}
}
public abstract void increment();
}
// Synchronize the entire method :
class PairManager1 extends PairManager
{
@Override
public synchronized void increment()
{
p.incrementX();
p.incrementY();
}
}
// Use a critical section
class PairManager2 extends PairManager
{
Pair temp;
@Override
public void increment()
{
p.incrementX();
p.incrementY();
temp = p;
}
}
class PairManipulartor implements Runnable
{
private PairManager pm;
public PairManipulartor(PairManager pm)
{
this.pm = pm;
}
@Override
public void run()
{
while (true)
pm.increment();
}
@Override
public String toString()
{
return "Pair : " + pm.getPair() + " checkCounter = " + pm.checkCounter.get();
}
}
class PairChecker implements Runnable
{
private PairManager pm;
public PairChecker(PairManager pm)
{
this.pm = pm;
}
@Override
public void run()
{
while (true)
{
pm.checkCounter.incrementAndGet();
pm.getPair().checkState();
}
}
}
Synchronized和ReentrantLock包装线程不安全的类_demo
最新推荐文章于 2022-06-12 21:49:18 发布