比较LongAdder、AtomicLong、synchronized(Long)效率
public class AtomicVsSyncVsLongAdder {
static long count2 = 0L;
static AtomicLong count1 = new AtomicLong(0L);
static LongAdder count3 = new LongAdder();
public static void main(String[] args) throws Exception {
Thread[] threads = new Thread[1000];
for (int i = 0; i < threads.length; i++) {
threads[i] =
new Thread(() -> {
for (int k = 0; k < 100000; k++) count1.incrementAndGet();
});
}
long start = System.currentTimeMillis();
for (Thread t : threads) t.start();
for (Thread t : threads) t.join();
long end = System.currentTimeMillis();
//TimeUnit.SECONDS.sleep(10);
System.out.println("Atomic: " + count1.get() + " time " + (end - start));
//-----------------------------------------------------------
Object lock = new Object();
for (int i = 0; i < threads.length; i++) {
threads[i] =
new Thread(() -> {
for (int k = 0; k < 100000; k++)
synchronized (lock) {
count2++;
}
});
}
start = System.currentTimeMillis();
for (Thread t : threads) t.start();
for (Thread t : threads) t.join();
end = System.currentTimeMillis();
System.out.println("Sync: " + count2 + " time " + (end - start));
//----------------------------------
for (int i = 0; i < threads.length; i++) {
threads[i] =
new Thread(() -> {
for (int k = 0; k < 100000; k++) count3.increment();
});
}
start = System.currentTimeMillis();
for (Thread t : threads) t.start();
for (Thread t : threads) t.join();
end = System.currentTimeMillis();
//TimeUnit.SECONDS.sleep(10);
System.out.println("LongAdder: " + count1.longValue() + " time " + (end - start));
}
static void microSleep(int m) {
try {
TimeUnit.MICROSECONDS.sleep(m);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
这个小程序用了1000个线程,每个线程分别将值从0到100000递增,然后计算所用的时间,结果如下图所示
可以看到LongAdder效率最高,其次是AtomicLong,synchronize最慢
原因是AtomicLong是CAS(无锁)效率比synchronize高,而LongAdder是使用分段锁,将1000个线程分成5份,200个线程一组去加值,最后将5个加起来的结果再相加,优势是在线程较多的情况下效率比AtomicLong更高
可重入锁 ReentrantLock
- ReentrantLock是一种可重入锁,跟synchronized作用差不多,但功能比synchronized要多,比如ReentrantLock可以设置等待时间,假如在指定时间内未拿到锁,则会放弃,代码如下
Lock lock = new ReentrantLock();
void m1() {
try {
lock.lock();
for (int i = 0; i < 10; i++) {
TimeUnit.SECONDS.sleep(1);
System.out.println(i);
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
/**
* 使用tryLock进行尝试锁定,不管锁定与否,方法都将继续执行
* 可以根据tryLock的返回值来判定是否锁定
* 也可以指定tryLock的时间,由于tryLock(time)抛出异常,所以要注意unclock的处理,必须放到finally中
*/
void m2() {
boolean locked = false;
try {
locked = lock.tryLock(5, TimeUnit.SECONDS);
System.out.println("m2 ..." + locked);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
if(locked) lock.unlock();
}
}
public static void main(String[] args) {
ReentrantLockDemo2 rl = new ReentrantLockDemo2();
new Thread(rl::m1).start();
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(rl::m2).start();
}
结果:m2 …false,如果将循环次数改为4,则结果为m2 …true
公平锁 非公平锁
ReentrantLock可以在构造的时候进行设置是否为公平锁,公平锁不是绝对公平,而是相对公平,看代码
public class ReentrantLockDemo3 extends Thread {
//参数为true表示为公平锁,请对比输出结果
private static ReentrantLock lock = new ReentrantLock(true);
@Override
public void run() {
for (int i = 0; i < 100; i++) {
lock.lock();
try {
System.out.println(Thread.currentThread().getName() + "获得锁");
} finally {
lock.unlock();
}
}
}
public static void main(String[] args) {
ReentrantLockDemo3 rl = new ReentrantLockDemo3();
Thread th1 = new Thread(rl);
Thread th2 = new Thread(rl);
th1.start();
th2.start();
}
结果是两个线程基本交替打印
CountDownLatch 门栓
- 是门栓,可以用在等待线程执行完毕后再进行业务的场景下,代码如下
public class CountDownLatchDemo {
public static void main(String[] args) {
usingCountDown();
// usingJoin();
}
private static void usingCountDown() {
Thread[] threads = new Thread[100];
CountDownLatch latch = new CountDownLatch(threads.length);
for (int i = 0; i < threads.length; i++) {
int finalI = i;
threads[i] = new Thread(() -> {
int result = 0;
for (int j = 0; j < 100; j++) {
result += j;
}
System.out.println("thread " + finalI + " result = " + result);
latch.countDown();
});
}
for (Thread thread : threads) {
thread.start();
}
try {
// 这段代码处于阻塞状态,当100个线程都执行完毕的时候才打印countDown end...
latch.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("countDown end...");
}
private static void usingJoin() {
Thread[] threads = new Thread[100];
for (int i = 0; i < threads.length; i++) {
int finalI = i;
threads[i] = new Thread(() -> {
int result = 0;
for (int j = 0; j < 100; j++) {
result += j;
}
System.out.println("thread " + finalI + " result = " + result);
});
}
for (Thread thread1 : threads) {
thread1.start();
}
for (Thread thread : threads) {
try {
thread.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("end join");
}
}
CyclicBarrier 栅栏
- 栅栏的作用是等待,等待线程达到一定数量的时候,推到,运行一段逻辑,请看下面的示例
public class CyclicBarrierDemo {
public static void main(String[] args) {
CyclicBarrier barrier = new CyclicBarrier(20, () -> System.out.println("满人,发车"));
for (int i = 0; i < 100; i++) {
new Thread(() -> {
try {
barrier.await();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (BrokenBarrierException e) {
e.printStackTrace();
}
}).start();
}
}
}
执行结果:就是打印5次 满人,发车
读写锁 ReadWriteLock
- 读锁ReentrantReadWriteLock.WriteLock本质上是一把共享锁
- 写锁ReentrantReadWriteLock.ReadLock本质上是一把排它锁
看下面一段程序,可以发现假如都是用共享锁,大概需要20秒的时间才能执行完,但是当是用读锁和写锁,则大概只需要3秒钟时间
public class ReadWriteLockDemo {
private static int value;
// 定义一个排他锁
static Lock lock = new ReentrantLock();
// 定义读写锁
static ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
// 读锁
static Lock readLock = readWriteLock.readLock();
// 写锁
static Lock writeLock = readWriteLock.writeLock();
public static void read(Lock lock) {
try {
lock.lock();
TimeUnit.SECONDS.sleep(1);
System.out.println("read over...");
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
public static void write(Lock lock, int v) {
try {
lock.lock();
TimeUnit.SECONDS.sleep(1);
value = v;
System.out.println("write over!");
//模拟写操作
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
public static void main(String[] args) {
// 排他锁
// Runnable readR = ()->read(lock);
// 读锁 共享锁
Runnable readR = () -> read(readLock);
// 排他锁
// Runnable writeR = () -> write(lock, 10);
// 写锁 排它锁
Runnable writeR = () -> write(writeLock, 10);
for(int i=0; i<18; i++) new Thread(readR).start();
for(int i=0; i<2; i++) new Thread(writeR).start();
}
}
信号量 Semaphore
- Semaphore作用是限流,用来限制同时运行的线程数
- 车道 加油站
简单使用代码
public class SemaphoreDemo {
public static void main(String[] args) {
//Semaphore s = new Semaphore(2);
Semaphore s = new Semaphore(2, true);
//允许一个线程同时执行
//Semaphore s = new Semaphore(1);
new Thread(()->{
try {
s.acquire();
System.out.println("T1 running...");
Thread.sleep(200);
System.out.println("T1 running...");
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
s.release();
}
}).start();
new Thread(()->{
try {
s.acquire();
System.out.println("T2 running...");
Thread.sleep(200);
System.out.println("T2 running...");
s.release();
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();
}
}