一般说的java高并发,基本是讲3个方面的
01,同步,包括synchronized 和各种锁
02,同步容器,比如ConcurrentHashMap等
03,线程池
01,synchronized跟ReentrantLock的区别
01,发生异常时,前者会释放锁,而后者不会
02,ReentrantLock可以进行尝试锁定,如果一段时间内锁定失败了,就可以执行其他操作,而不必一直等待,在灵活性上,要比synchronized要好。
03,在性能上,一般的说法是,当并发度不高的时候,性能区别是不大的。
04,在线程打断机制上面,重入锁更好用
05,两种锁默认都不是公平锁,ReentrantLock可以是设置为公平锁。
06,ReentrantLock锁的Condition可以做到对线程唤醒的精确控制
02,通过一个例子学习重入锁的打断机制
final ReentrantLock lock = new ReentrantLock();
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
try {
lock.lockInterruptibly();//
System.out.println("t1正在执行");
TimeUnit.SECONDS.sleep(5);
System.out.println("t1执行完毕");
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
if(lock.isLocked()){
lock.unlock();
System.out.println("刚刚释放了t1的锁");
}else {
System.out.println("t1的锁已经被释放了");
}
}
}
});
t1.start();
TimeUnit.SECONDS.sleep(2);
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
lock.lock();
try {
System.out.println("t2执行了");
}catch (Exception e){
e.printStackTrace();
}finally {
lock.unlock();
}
}
});
t2.start();
TimeUnit.SECONDS.sleep(1);
t1.interrupt();
}
从上面的例子可以看出,使用重入锁的线程,是可以被打段的。前提是用锁的可打算方法去锁。比如一个线程老是占用资源不撒手,其他线程可以主动打断它,但是,打断后,也要进行锁的释放,否则其他线程还是拿不到锁。
03,现在面试问生产者,消费者的情况非常多,下面给出一个生产者消费者小例子,注意,90%以上的情况,wait需要跟while配对。
这里写
04,举一个非线程安全的例子
final List<Integer> list = new ArrayList<>();
Thread[] threads = new Thread[100];
CountDownLatch countDownLatch = new CountDownLatch(threads.length);
for (int i = 0; i < threads.length; i++) {
threads[i] = new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 1000; i++) {
list.add(24);
}
}
});
}
for (int i = 0; i < threads.length; i++) {
threads[i].start();
countDownLatch.countDown();
}
countDownLatch.await();
System.out.println(list.size());