synchronized锁和Lock锁
synchronized
对象锁-使用方式1
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
public class Demo2 {
public static void main(String[] args) {
Demo2 demo = new Demo2();
Thread t1 = new Thread(()->{
demo.a();
});
Thread t2 = new Thread(()->{
demo.b();
});
t1.start();
t2.start();
}
public synchronized void a() {
try {
System.out.println("aaaaaaaaaa");
TimeUnit.SECONDS.sleep(3);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
public synchronized void b() {
try {
System.out.println("bbbbbbbbbbbbbbbb");
TimeUnit.SECONDS.sleep(3);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
}
上边代码示例中t1和t2两个线程使用同一个Demo2对象分别调用a,b两个方法。两个线程的执行是串行的。因为synchronized在方法上则默认使用当前对象锁。
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
public class Demo2 {
public static void main(String[] args) {
Thread t1 = new Thread(()->{
Demo2 demo = new Demo2();
demo.a();
});
Thread t2 = new Thread(()->{
Demo2 demo = new Demo2();
demo.b();
});
t1.start();
t2.start();
}
public synchronized void a() {
try {
System.out.println("aaaaaaaaaa");
TimeUnit.SECONDS.sleep(3);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
public synchronized void b() {
try {
System.out.println("bbbbbbbbbbbbbbbb");
TimeUnit.SECONDS.sleep(3);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
}
在每个线程内创建自己的Demo2对象,两个线程则是并行的。
对象锁-使用方式2
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
public class Demo2 {
public static void main(String[] args) {
Object lock = new Object();
Demo2 demo = new Demo2();
Thread t1 = new Thread(() -> {
demo.a(lock);
});
Thread t2 = new Thread(() -> {
demo.b(lock);
});
t1.start();
t2.start();
}
public void a(Object lock) {
synchronized (lock) {
try {
System.out.println("aaaaaaaaaa");
TimeUnit.SECONDS.sleep(3);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
}
public void b(Object lock) {
synchronized (lock) {
try {
System.out.println("bbbbbbbbbbbbbbbb");
TimeUnit.SECONDS.sleep(3);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
}
}
将synchronized转移到方法内部,组成一个同步代码块,同步代码块接收一个对象类型的参数。在main中创建了一个Object对象,将这个对象分别传递给两个线程的a,b方法。执行结果是串行的,因为两个线程使用的是同一个对象,即同一个锁。
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
public class Demo2 {
public static void main(String[] args) {
Thread t1 = new Thread(() -> {
Demo2 demo = new Demo2();
demo.a();
});
Thread t2 = new Thread(() -> {
Demo2 demo = new Demo2();
demo.b();
});
t1.start();
t2.start();
}
public void a() {
synchronized (this) {
try {
System.out.println("aaaaaaaaaa");
TimeUnit.SECONDS.sleep(3);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
}
public void b() {
synchronized (this) {
try {
System.out.println("bbbbbbbbbbbbbbbb");
TimeUnit.SECONDS.sleep(3);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
}
}
将代码稍稍修改,每个线程都使用自己的Demo2对象,而同步代码块中写this,这表示每个线程的锁都是自己的Demo2对象,所以结果是并行执行。同步代码块中的对象可以是任意对象,但是使用同一个对象的方法必然会互斥。
类锁-使用方式1
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
public class Demo2 {
public static void main(String[] args) {
Thread t1 = new Thread(() -> {
Demo2.a();
});
Thread t2 = new Thread(() -> {
Demo2.b();
});
t1.start();
t2.start();
}
public synchronized static void a() {
try {
System.out.println("aaaaaaaaaa");
TimeUnit.SECONDS.sleep(3);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
public synchronized static void b() {
try {
System.out.println("bbbbbbbbbbbbbbbb");
TimeUnit.SECONDS.sleep(3);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
}
在static方法上使用synchronizedz则表示synchronized使用的是当前类对象。以上代码是串行执行的。
类锁-使用方式2
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
public class Demo2 {
public static void main(String[] args) {
Thread t1 = new Thread(() -> {
Demo2.a();
});
Thread t2 = new Thread(() -> {
Demo2.b();
});
t1.start();
t2.start();
}
public static void a() {
synchronized (Demo2.class) {
try {
System.out.println("aaaaaaaaaa");
TimeUnit.SECONDS.sleep(3);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
}
public static void b() {
synchronized (Demo2.class) {
try {
System.out.println("bbbbbbbbbbbbbbbb");
TimeUnit.SECONDS.sleep(3);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
}
}
在static方法内部使用synchronized代码块,代码块中只能接收类对象,以上代码传的是同一个类对象Demo2.class。所以执行结果是串行的。
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
public class Demo2 {
public static void main(String[] args) {
Thread t1 = new Thread(() -> {
Demo2.a();
});
Thread t2 = new Thread(() -> {
Demo2.b();
});
t1.start();
t2.start();
}
public static void a() {
synchronized (Demo2.class) {
try {
System.out.println("aaaaaaaaaa");
TimeUnit.SECONDS.sleep(3);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
}
public static void b() {
synchronized (Object.class) {
try {
System.out.println("bbbbbbbbbbbbbbbb");
TimeUnit.SECONDS.sleep(3);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
}
}
将代码修改为a和b分别持有Demo2.class和Object.class执行结果是并行的。这种写法可以接收任意的class。
Lock锁
在JDK5有了java.util.concurrent包,也就是大家说的JUC,Lock接口在JUC的子包java.util.concurrent.locks中。ReentrantLock是其中的一个实现。
lock()-unlock()
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
public class Test1 {
public static void main(String[] args) {
ReentrantLock lock = new ReentrantLock();
Test1 test1 = new Test1();
Thread t1 = new Thread(() -> {
test1.a(lock);
});
Thread t2 = new Thread(() -> {
test1.b(lock);
});
t1.start();
t2.start();
}
public void a(Lock lock) {
try {
lock.lock();
System.out.println("aaaaaaaaaa");
TimeUnit.SECONDS.sleep(3);
} catch (Exception e) {
throw new RuntimeException(e);
} finally {
lock.unlock();
}
}
public void b(Lock lock) {
try {
lock.lock();
System.out.println("bbbbbbbbbbbbbbbb");
TimeUnit.SECONDS.sleep(3);
} catch (Exception e) {
throw new RuntimeException(e);
} finally {
lock.unlock();
}
}
}
a,b两个方法使用的是同一个ReentrantLock对象,只有同一个lock才能有锁的效果,以上代码是串行执行的。lock()加锁,unlock()解锁。它们是同一组操作。
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
public class Test1 {
public static void main(String[] args) {
ReentrantLock lock = new ReentrantLock();
ReentrantLock lock2 = new ReentrantLock();
Test1 test1 = new Test1();
Thread t1 = new Thread(() -> {
test1.a(lock);
});
Thread t2 = new Thread(() -> {
test1.b(lock2);
});
t1.start();
t2.start();
}
public void a(Lock lock) {
try {
lock.lock();
System.out.println("aaaaaaaaaa");
TimeUnit.SECONDS.sleep(3);
} catch (Exception e) {
throw new RuntimeException(e);
} finally {
lock.unlock();
}
}
public void b(Lock lock) {
try {
lock.lock();
System.out.println("bbbbbbbbbbbbbbbb");
TimeUnit.SECONDS.sleep(3);
} catch (Exception e) {
throw new RuntimeException(e);
} finally {
lock.unlock();
}
}
}
如果在增加一个ReentrantLock对象,a,b两个方法使用的不是同一个,运行结果就是并行的。
tryLock()
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
public class Test2 {
public static void main(String[] args) {
ReentrantLock lock = new ReentrantLock();
Test2 test1 = new Test2();
Thread t1 = new Thread(() -> {
test1.a(lock);
});
Thread t2 = new Thread(() -> {
test1.b(lock);
});
t1.start();
t2.start();
}
public void a(Lock lock) {
boolean b = lock.tryLock();
if (b) {
try {
System.out.println("aaaaaaaaaa");
TimeUnit.SECONDS.sleep(3);
} catch (Exception e) {
throw new RuntimeException(e);
} finally {
lock.unlock();
}
} else {
System.out.println("获取锁失败");
}
}
public void b(Lock lock) {
boolean b = lock.tryLock();
if (b) {
try {
System.out.println("bbbbbbbbbbbbbbbb");
TimeUnit.SECONDS.sleep(3);
} catch (Exception e) {
throw new RuntimeException(e);
} finally {
lock.unlock();
}
} else {
System.out.println("获取锁失败");
}
}
}
如果一个线程通过tryLock获取锁失败则会返回false,返回true则表示拿到了锁。
tryLock(long time, TimeUnit unit)
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
public class Test3 {
public static void main(String[] args) {
ReentrantLock lock = new ReentrantLock();
Test3 test1 = new Test3();
Thread t1 = new Thread(() -> {
test1.a(lock);
});
Thread t2 = new Thread(() -> {
test1.b(lock);
});
t1.start();
t2.start();
}
public void a(Lock lock) {
boolean b = false;
try {
b = lock.tryLock(2, TimeUnit.SECONDS);
} catch (Exception e) {
throw new RuntimeException(e);
}
if (b) {
try {
System.out.println("aaaaaaaaaa");
TimeUnit.SECONDS.sleep(3);
} catch (Exception e) {
throw new RuntimeException(e);
} finally {
lock.unlock();
}
} else {
System.out.println("获取锁失败");
}
}
public void b(Lock lock) {
boolean b = false;
try {
b = lock.tryLock(2, TimeUnit.SECONDS);
} catch (Exception e) {
throw new RuntimeException(e);
}
if (b) {
try {
System.out.println("bbbbbbbbbbbbbbbb");
TimeUnit.SECONDS.sleep(3);
} catch (Exception e) {
throw new RuntimeException(e);
} finally {
lock.unlock();
}
} else {
System.out.println("获取锁失败");
}
}
}
在设定的time时间内如果还是没有获取到锁,才返回false。
lockInterruptibly()
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
public class Test4 {
public static void main(String[] args) {
ReentrantLock lock = new ReentrantLock();
Test4 test1 = new Test4();
Thread t1 = new Thread(() -> {
test1.a(lock);
});
Thread t2 = new Thread(() -> {
test1.b(lock);
});
t1.start();
try {
TimeUnit.SECONDS.sleep(1);
} catch (Exception e) {
}
t2.start();
/* t1.interrupt();执行结果
aaaaaaaaaa
Exception in thread "Thread-0" java.lang.RuntimeException: aaaaaaaaaaaaaaaa打断施法java.lang.InterruptedException: sleep interrupted
at com.dfsn.cloud.consumer.locks.Test4.a(Test4.java:51)
at com.dfsn.cloud.consumer.locks.Test4.lambda$main$0(Test4.java:15)
at java.lang.Thread.run(Thread.java:748)
bbbbbbbbb*/
// t1.interrupt();
/* t2.interrupt();的执行结果
aaaaaaaaaa
Exception in thread "Thread-1" java.lang.RuntimeException: bbbbbbbbbbbb打断施法java.lang.InterruptedException
at com.dfsn.cloud.consumer.locks.Test4.b(Test4.java:52)
at com.dfsn.cloud.consumer.locks.Test4.lambda$main$1(Test4.java:19)
at java.lang.Thread.run(Thread.java:748)*/
// t2.interrupt();
}
public void a(Lock lock) {
try {
lock.lockInterruptibly();
} catch (Exception e) {
throw new RuntimeException(e);
}
try {
System.out.println("aaaaaaaaaa");
TimeUnit.SECONDS.sleep(3);
} catch (Exception e) {
throw new RuntimeException("aaaaaaaaaaaaaaaa打断施法" + e);
} finally {
lock.unlock();
}
}
public void b(Lock lock) {
try {
lock.lockInterruptibly();
} catch (Exception e) {
throw new RuntimeException("bbbbbbbbbbbb打断施法" + e);
}
try {
System.out.println("bbbbbbbbb");
TimeUnit.SECONDS.sleep(3);
} catch (Exception e) {
throw new RuntimeException(e);
} finally {
lock.unlock();
}
}
}
这个方法牵扯到Thread类中的interrupted()方法。对启动的线程使用interrupted方法,则该线程会接收到一个中断的信号,该信号不会停止线程的运行,但如果线程内有调用wait,join,sleep等方法,则会收到一InterruptedException异常。
使用lockInterruptibly()获取锁,然后调用线程的interrupted()如果当前线程已经获取到了锁正在运行中,线程则会接收一个中断信号量,如上所说。但如果当前线程没有获取到锁,处于等待状态,则lockInterruptibly()也会抛出一个InterruptedException。
公平锁和非公平锁
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
public class Demo5 {
private Lock lock = new ReentrantLock(false); //如果不传递等于传递false,可以传递true表示公平锁
public static void main(String[] args) throws InterruptedException {
final Demo5 test = new Demo5();
test.lock.lock();
Thread t1 = new Thread() {
@Override
public void run() {
test.insert(Thread.currentThread());
}
};
t1.start();
Thread t2 = new Thread() {
@Override
public void run() {
test.insert(Thread.currentThread());
}
};
t2.start();
Thread t3 = new Thread() {
@Override
public void run() {
test.insert(Thread.currentThread());
}
};
t3.start();
Thread t4 = new Thread() {
@Override
public void run() {
test.insert(Thread.currentThread());
}
};
t4.start();
Thread t5 = new Thread() {
@Override
public void run() {
test.insert(Thread.currentThread());
}
};
t5.start();
Thread t6 = new Thread() {
@Override
public void run() {
test.insert(Thread.currentThread());
}
};
t6.start();
test.lock.unlock();
}
创建ReentrantLock时如果不传递参数则默认是false非公平锁。如果是公平锁得情况下会根据线程的等待顺序分配锁,而非公平锁则是随机分配。
ReentrantLock的其他方法
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
public class Demo6 extends ReentrantLock{
public static void main(String[] args) throws InterruptedException {
final Demo6 test = new Demo6();
test.lock();
Thread t1 = new Thread() {
@Override
public void run() {
test.insert(Thread.currentThread());
}
};
t1.start();
Thread t2 = new Thread() {
@Override
public void run() {
test.insert(Thread.currentThread());
}
};
t2.start();
Thread t3 = new Thread() {
@Override
public void run() {
test.insert(Thread.currentThread());
}
};
t3.start();
Thread t4 = new Thread() {
@Override
public void run() {
test.insert(Thread.currentThread());
}
};
t4.start();
Thread t5 = new Thread() {
@Override
public void run() {
test.insert(Thread.currentThread());
}
};
t5.start();
Thread t6 = new Thread() {
@Override
public void run() {
test.insert(Thread.currentThread());
}
};
t6.start();
System.out.println("查询此锁是否由当前线程持有。"+test.isLocked());
System.out.println("查询此锁是否由任何线程持有。"+test.isLocked());
System.out.println("如果此锁的公平设置为true,则返回 true 。"+test.isFair());
System.out.println("查询是否有线程正在等待获取此锁。"+test.hasQueuedThreads());
System.out.println("查询给定线程是否等待获取此锁。"+test.hasQueuedThread(t1));
System.out.println("返回等待获取此锁的线程数的估计。"+test.getQueueLength());
System.out.println("返回当前拥有此锁的线程,如果不拥有,则返回 null 。"+test.getOwner().getName());
System.out.println("查询当前线程对此锁的暂停数量。"+test.getHoldCount());
System.out.println("返回包含可能正在等待获取此锁的线程的集合。"+test.getQueuedThreads().size());
test.unlock();
System.out.println("查询此锁是否由当前线程持有。"+test.isLocked());
Thread.sleep(2000);
System.out.println("查询是否有线程正在等待获取此锁。"+test.hasQueuedThreads());
System.out.println("查询给定线程是否等待获取此锁。"+test.hasQueuedThread(t1));
System.out.println("返回等待获取此锁的线程数的估计。"+test.getQueueLength());
System.out.println("返回当前拥有此锁的线程,如果不拥有,则返回 null 。"+test.getOwner());
System.out.println("查询当前线程对此锁的暂停数量。"+test.getHoldCount());
System.out.println("返回包含可能正在等待获取此锁的线程的集合。"+test.getQueuedThreads().size());
}
public void insert(Thread thread) {
lock();
try {
System.out.println(thread.getName() + "得到了锁");
Thread.sleep(1000);
} catch (Exception e) {
System.out.println(e);
} finally {
System.out.println(thread.getName() + "释放了锁");
unlock();
}
}
}