同步锁实例

此列统计三种同步锁并发访问时消耗的时间

public interface Counter {

    public long getValue();

    public void increment();

}

/**

 * 内部锁

 */

public class SynchronizedBenchmarkDemo implements Counter {

    private long count = 0;



    @Override

    public long getValue() {

        return count;

    }



    @Override

    public synchronized void increment() {

        count++;

    }



}

import java.util.concurrent.locks.Lock;

import java.util.concurrent.locks.ReentrantLock;



/**

 * 不公平重入锁

 */

@SuppressWarnings("all")

public class ReentrantLockUnfairBeanchmarkDemo implements Counter {

    private volatile long count = 0;

    private Lock lock;



    public ReentrantLockUnfairBeanchmarkDemo() {

        // 使用不公平锁

        lock = new ReentrantLock(false);

    }



    @Override

    public long getValue() {

        return count;

    }



    @Override

    public void increment() {

        lock.lock();

        try {

            count++;

        } finally {

            lock.unlock();

        }

    }



}

import java.util.concurrent.locks.Lock;

import java.util.concurrent.locks.ReentrantLock;



/**

 * 公平重入锁

 */

@SuppressWarnings("all")

public class ReentrantLockFairBeanchmarkDemo implements Counter {

    private volatile long count = 0;

    private Lock lock;



    public ReentrantLockFairBeanchmarkDemo() {

        // 创建公平锁

        lock = new ReentrantLock(true);

    }



    @Override

    public long getValue() {

        return count;

    }



    @Override

    public void increment() {

        lock.lock();

        try {

            count++;

        } finally {

            lock.unlock();

        }

    }



}

import java.util.concurrent.BrokenBarrierException;

import java.util.concurrent.CyclicBarrier;



/**

 * 三种类型的同步锁：内部锁、不公平锁、公平锁，每种类型的锁各自创建2000个线程，然后每个线程访问带有锁得变量100次，并加1。

 * 统计各种锁并发访问时消耗的时间

 *

 * @author Administrator

 *

 */

@SuppressWarnings("all")

public class BenchmarkTest {

    private Counter counter;

    // 一个同步辅助类，它允许一组线程互相等待，直到到达某个公共屏障点

    private CyclicBarrier barrier;

    private int threadNum;

    private int loopNum;

    private String testName;

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

     * 用于记录由该对象创建的threadNum线程统开始循环和结束循环的起止时间

     */

    public long begin;

    public long end;



    private BenchmarkTest(Counter counter, int threadNum, int loopNum, String testName) {

        this.counter = counter;

        this.threadNum = threadNum;

        this.loopNum = loopNum;

        this.testName = testName;

        barrier = new CyclicBarrier(threadNum, new BarrierTime(this));

    }



    public void test() {

        try {

            for (int i = 0; i < threadNum; i++) {

                new TestThread(counter, loopNum, this).start();

            }

        } catch (Exception e) {

            e.printStackTrace();

        }

    }



    public static void main(String[] args) {

        try {

            int threadNum = 2000;

            int loopNum = 100;



            new BenchmarkTest(new SynchronizedBenchmarkDemo(), threadNum, loopNum, "内部锁").test();

            Thread.sleep(5000);



            new BenchmarkTest(new ReentrantLockUnfairBeanchmarkDemo(), threadNum, loopNum, "不公平锁").test();

            Thread.sleep(5000);



            new BenchmarkTest(new ReentrantLockFairBeanchmarkDemo(), threadNum, loopNum, "公平锁锁").test();

        } catch (InterruptedException e) {

            e.printStackTrace();

        }

    }



    class TestThread extends Thread {

        int loopNum = 100;

        private Counter counter;

        private BenchmarkTest benchmarkTest;



        private TestThread(final Counter counter, int loopNum, BenchmarkTest benchmarkTest) {

            this.counter = counter;

            this.loopNum = loopNum;

            this.benchmarkTest = benchmarkTest;

        }



        public void run() {

            try {

                // 等待所有线程开始

                barrier.await();

                for (int i = 0; i < this.loopNum; i++) {

                    counter.increment();

                }

                // 等待所有线程结束

                barrier.await();

            } catch (Exception e) {

                throw new RuntimeException();

            }

        }

    }



    class BarrierTime implements Runnable {

        private BenchmarkTest benchmarkTest;



        public BarrierTime(BenchmarkTest benchmarkTest) {

            this.benchmarkTest = benchmarkTest;

        }



        @Override

        public void run() {

            if (benchmarkTest.begin == 0) {

                benchmarkTest.begin = System.currentTimeMillis();

            } else {

                benchmarkTest.end = System.currentTimeMillis();

            }

            if (benchmarkTest.end != 0) {

                System.out.println(benchmarkTest.testName + "共花费时间：" + (benchmarkTest.end - benchmarkTest.begin) + "毫秒");

            }

        }



    }

}

运行结果：

内部锁共花费时间：156毫秒

不公平锁共花费时间：16毫秒

公平锁锁共花费时间：1234毫秒