Synchronized和ReentrantLock包装线程不安全的类_demo

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();
}
}

}