lock
lock于synchronized相比更有优势,或者是说有不同的地方。
lock于synchronized的区别?
synchronized一个线程获取锁别的线程都在等待,synchronized当前的方法或者代码块
会自动释放锁,然后让别的线程去获取。synchronized代码块抛出异常也会自动释放锁
lock就是一个线程获取锁,别的线程会尝试获取锁,如果获取多的话也没关系,也不会等
待,做别的事情,其次lock需要手动释放锁。lock抛出异常不会自动释放锁,也要手动释
放锁,lock手动释放锁需要写在finnlly里面。
源码:
lock是一个接口。有lock方法。有lockInterruptibly方法,还有trylock,还有
unlock.
ReentrantLock是对lock的实现。Lock就是一把锁。或取一个对象的锁。lock.lock();
如下:第二个线程锁不会获取。只会输出1 11 2 ,不会输出22。
package test08;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class Test {
public static void main(String[] args) {
//lock
final Lock lock = new ReentrantLock();
new Thread(){
public void run(){
System.out.println(1);
lock.lock();
System.out.println(11);
}
}.start();
new Thread(){
public void run(){
System.out.println(2);
lock.lock();
System.out.println(22);
}
}.start();
}
}
要想输出需要自动释放锁。在输出11或者输出22的那try 一下,写finally,在finally
里手动释放锁。
package test08;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class Test {
public static void main(String[] args) {
//lock
final Lock lock = new ReentrantLock();
new Thread(){
public void run(){
System.out.println(1);
lock.lock();
try {
System.out.println(11);
} finally{
lock.unlock();
System.out.println(111);
}
}
}.start();
new Thread(){
public void run(){
System.out.println(2);
lock.lock();
System.out.println(22);
}
}.start();
}
}
LOCK
第一个线程开始获取锁,就会输出我以获取锁,睡眠3秒释放锁,第二个线程无法获取锁,
就会输出没有获取锁。
package test08;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class Test {
public static void main(String[] args) {
final Lock lock = new ReentrantLock();
new Thread(){
public void run(){
System.out.println("开始。。。");
if(lock.tryLock()){
try{
System.out.println("我以获取到锁");
}finally{
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
lock.unlock();
}
}else{
System.out.println("我没有获取到锁");
}
}
}.start();
new Thread(){
public void run(){
System.out.println("开始。。。");
if(lock.tryLock()){
try{
System.out.println("我以获取到锁");
}finally{
lock.unlock();
}
}else{
System.out.println("我没有获取到锁");
}
}
}.start();
}
}
第一个线程开始获取锁,就会输出我以获取锁,睡眠3秒释放锁,第二个线程5秒后获取锁
,就会输出我以获取锁
package test08;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class Test {
public static void main(String[] args) {
final Lock lock = new ReentrantLock();
new Thread(){
public void run(){
System.out.println("开始。。。");
if(lock.tryLock()){
try{
System.out.println("我以获取到锁");
}finally{
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
lock.unlock();
}
}else{
System.out.println("我没有获取到锁");
}
}
}.start();
new Thread(){
public void run(){
System.out.println("开始。。。");
try {
if(lock.tryLock(5000L, TimeUnit.MILLISECONDS)){
try{
System.out.println("我以获取到锁");
}finally{
lock.unlock();
}
}else{
System.out.println("我没有获取到锁");
}
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}.start();
}
}