使用synchronized和Lock对象获取对象锁

 Java:使用synchronized和Lock对象获取对象锁

 

 

下面使用ReentrantLock这个锁来实现加锁功能：

 

 

package com.tch.test.concurrent;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class SynchronizedTest {

private ExecutorService pool = Executors.newFixedThreadPool(4);
private Lock lock = new ReentrantLock();

public static void main(String[] args) {
new SynchronizedTest().test();
}

public void test() {
Runnable runnable = null;
for(int i=0;i<4;i++){
runnable = new Runnable(){
public void run(){
while(true){
execute();
}
}
};
pool.execute(runnable);
}
}
void execute(){
lock.lock();//首先获得锁
try{
System.out.println(Thread.currentThread().getId()+"获得了lock，开始休息");
Thread.sleep(300);
}catch(Exception e){}
finally{
System.out.println(Thread.currentThread().getId()+"释放了lock,结束休息");
lock.unlock();//最后一定要释放锁
}
}
}

 

 

然后使用java的synchronized关键字实现加锁：

 

 

package com.tch.test.concurrent;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class SynchronizedTest {

private ExecutorService pool = Executors.newFixedThreadPool(4);
//private Lock lock = new ReentrantLock();
private Object obj = new Object();

public static void main(String[] args) {
new SynchronizedTest().test();
}

public void test() {
Runnable runnable = null;
for(int i=0;i<4;i++){
runnable = new Runnable(){
public void run(){
while(true){
execute();
}
}
};
pool.execute(runnable);
}
}
void execute(){
synchronized(obj){
try {
System.out.println(Thread.currentThread().getId()+"获得了obj的锁，开始休息");
Thread.sleep(300);
System.out.println(Thread.currentThread().getId()+"释放了obj的锁,结束休息");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}

 

 

 

 

 

在并发环境下，解决共享资源冲突问题时，可以考虑使用锁机制。

1.对象的锁

所有对象都自动含有单一的锁。

JVM负责跟踪对象被加锁的次数。如果一个对象被解锁，其计数变为0。在任务（线程）第一次给对象加锁的时候，计数变为1。每当这个相同的任务（线程）在此对象上获得锁时，计数会递增。

只有首先获得锁的任务（线程）才能继续获取该对象上的多个锁。

每当任务离开一个synchronized方法，计数递减，当计数为0的时候，锁被完全释放，此时别的任务就可以使用此资源。

2.synchronized同步块

2.1同步到单一对象锁

当使用同步块时，如果方法下的同步块都同步到一个对象上的锁，则所有的任务（线程）只能互斥的进入这些同步块。

Resource1.java演示了三个线程（包括main线程）试图进入某个类的三个不同的方法的同步块中，虽然这些同步块处在不同的方法中，但由于是同步到同一个对象（当前对象 synchronized (this)），所以对它们的方法依然是互斥的。

Resource1.java

package com.zj.lock; import java.util.concurrent.TimeUnit;   public class Resource1 {     public void f() {        // other operations should not be locked...        System.out.println(Thread.currentThread().getName()               + ":not synchronized in f()");        synchronized (this) {            for (int i = 0; i < 5; i++) {               System.out.println(Thread.currentThread().getName()                      + ":synchronized in f()");               try {                   TimeUnit.SECONDS.sleep(3);               } catch (InterruptedException e) {                   e.printStackTrace();               }            }        }     }       public void g() {        // other operations should not be locked...        System.out.println(Thread.currentThread().getName()               + ":not synchronized in g()");        synchronized (this) {            for (int i = 0; i < 5; i++) {               System.out.println(Thread.currentThread().getName()                      + ":synchronized in g()");               try {                   TimeUnit.SECONDS.sleep(3);               } catch (InterruptedException e) {                   e.printStackTrace();               }            }        }     }       public void h() {        // other operations should not be locked...        System.out.println(Thread.currentThread().getName()               +  20000 ":not synchronized in h()");        synchronized (this) {            for (int i = 0; i < 5; i++) {               System.out.println(Thread.currentThread().getName()                      + ":synchronized in h()");               try {                   TimeUnit.SECONDS.sleep(3);               } catch (InterruptedException e) {                   e.printStackTrace();               }            }        }     }       public static void main(String[] args) {        final Resource1 rs = new Resource1();          new Thread() {            public void run() {               rs.f();            }        }.start();          new Thread() {            public void run() {               rs.g();            }        }.start();          rs.h();     } }

结果：
Thread-0:not synchronized in f()
Thread-0:synchronized in f()
main:not synchronized in h()
Thread-1:not synchronized in g()
Thread-0:synchronized in f()
Thread-0:synchronized in f()
Thread-0:synchronized in f()
Thread-0:synchronized in f()
Thread-1:synchronized in g()
Thread-1:synchronized in g()
Thread-1:synchronized in g()
Thread-1:synchronized in g()
Thread-1:synchronized in g()
main:synchronized in h()
main:synchronized in h()
main:synchronized in h()
main:synchronized in h()
main:synchronized in h()

2.2 同步到多个对象锁

Resource1.java演示了三个线程（包括main线程）试图进入某个类的三个不同的方法的同步块中，这些同步块处在不同的方法中，并且是同步到三个不同的对象（synchronized (this)，synchronized(syncObject1)，synchronized (syncObject2)），所以对它们的方法中的临界资源访问是独立的。

Resource2.java

package com.zj.lock; import java.util.concurrent.TimeUnit;   public class Resource2 {     private Object syncObject1 = new Object();     private Object syncObject2 = new Object();       public void f() {        // other operations should not be locked...        System.out.println(Thread.currentThread().getName()               + ":not synchronized in f()");        synchronized (this) {            for (int i = 0; i < 5; i++) {               System.out.println(Thread.currentThread().getName()                      + ":synchronized in f()");               try {                   TimeUnit.SECONDS.sleep(3);               } catch (InterruptedException e) {                   e.printStackTrace();               }            }        }     }       public void g() {        // other operations should not be locked...        System.out.println(Thread.currentThread().getName()               + ":not synchronized in g()");        synchronized (syncObject1) {            for (int i = 0; i < 5; i++) {               System.out.println(Thread.currentThread().getName()                      + ":synchronized in g()");               try {                   TimeUnit.SECONDS.sleep(3);               } catch (InterruptedException e) {                   e.printStackTrace();               }            }        }     }       public void h() {        // other operations should not be locked...        System.out.println(Thread.currentThread().getName()               + ":not synchronized in h()");        synchronized (syncObject2) {            for (int i = 0; i < 5; i++) {               System.out.println(Thread.currentThread().getName()                      + ":synchronized in h()");               try {                   TimeUnit.SECONDS.sleep(3);               } catch (InterruptedException e) {                   e.printStackTrace();               }            }        }     }       public static void main(String[] args) {        final Resource2 rs = new Resource2();          new Thread() {            public void run() {               rs.f();            }        }.start();          new Thread() {            public void run() {               rs.g();            }        }.start();          rs.h();     } }

结果：
Thread-0:not synchronized in f()
Thread-0:synchronized in f()
main:not synchronized in h()
main:synchronized in h()
Thread-1:not synchronized in g()
Thread-1:synchronized in g()
Thread-0:synchronized in f()
main:synchronized in h()
Thread-1:synchronized in g()
Thread-0:synchronized in f()
main:synchronized in h()
Thread-1:synchronized in g()
Thread-0:synchronized in f()
main:synchronized in h()
Thread-1:synchronized in g()
Thread-0:synchronized in f()
main:synchronized in h()
Thread-1:synchronized in g()

3.Lock对象锁

除了使用synchronized外，还可以使用Lock对象来创建临界区。Resource3.java的演示效果同Resource1.java；Resource4.java的演示效果同Resource2.java。

Resource3.java

package com.zj.lock; import java.util.concurrent.TimeUnit; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock;   public class Resource3 {     private Lock lock = new ReentrantLock();       public void f() {        // other operations should not be locked...        System.out.println(Thread.currentThread().getName()               + ":not synchronized in f()");        lock.lock();        try {            for (int i = 0; i < 5; i++) {               System.out.println(Thread.currentThread().getName()                      + ":synchronized in f()");               try {                   TimeUnit.SECONDS.sleep(3);               } catch (InterruptedException e) {                   e.printStackTrace();               }            }        } finally {            lock.unlock();        }     }       public void g() {        // other operations should not be locked...        System.out.println(Thread.currentThread().getName()               + ":not synchronized in g()");        lock.lock();        try {            for (int i = 0; i < 5; i++) {               System.out.println(Thread.currentThread().getName()                      + ":synchronized in g()");               try {                   TimeUnit.SECONDS.sleep(3);               } catch (InterruptedException e) {                   e.printStackTrace();               }            }        } finally {            lock.unlock();        }     }       public void h() {        // other operations should not be locked...        System.out.println(Thread.currentThread().getName()               + ":not synchronized in h()");        lock.lock();        try {            for (int i = 0; i < 5; i++) {               System.out.println(Thread.currentThread().getName()                      + ":synchronized in h()");               try {                   TimeUnit.SECONDS.sleep(3);               } catch (InterruptedException e) {                   e.printStackTrace();               }            }        } finally {            lock.unlock();        }     }       public static void main(String[] args) {        final Resource3 rs = new Resource3();          new Thread() {            public void run() {               rs.f();            }        }.start();          new Thread() {            public void run() {               rs.g();            }        }.start();          rs.h();     } }

结果：
Thread-0:not synchronized in f()
Thread-0:synchronized in f()
main:not synchronized in h()
Thread-1:not synchronized in g()
Thread-0:synchronized in f()
Thread-0:synchronized in f()
Thread-0:synchronized in f()
Thread-0:synchronized in f()
main:synchronized in h()
main:synchronized in h()
main:synchronized in h()
main:synchronized in h()
main:synchronized in h()
Thread-1:synchronized in g()
Thread-1:synchronized in g()
Thread-1:synchronized in g()
Thread-1:synchronized in g()
Thread-1:synchronized in g()
Resource4.java

package com.zj.lock; import java.util.concurrent.TimeUnit; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock;   public class Resource4 {     private Lock lock1 = new ReentrantLock();     private Lock lock2 = new ReentrantLock();     private Lock lock3 = new ReentrantLock();       public void f() {        // other operations should not be locked...        System.out.println(Thread.currentThread().getName()               + ":not synchronized in f()");        lock1.lock();        try {            for (int i = 0; i < 5; i++) {               System.out.println(Thread.currentThread().getName()                      + ":synchronized in f()");               try {                   TimeUnit.SECONDS.sleep(3);               } catch (InterruptedException e) {                   e.printStackTrace();               }            }        } finally {            lock1.unlock();        }     }       public void g() {        // other operations should not be locked...        System.out.println(Thread.currentThread().getName()               + ":not synchronized in g()");        lock2.lock();        try {            for (int i = 0; i < 5; i++) {               System.out.println(Thread.currentThread().getName()                      + ":synchronized in g()");               try {                   TimeUnit.SECONDS.sleep(3);               } catch (InterruptedException e) {                   e.printStackTrace();               }            }        } finally {            lock2.unlock();        }     }       public void h() {        // other operations should not be locked...        System.out.println(Thread.currentThread().getName()               + ":not synchronized in h()");        lock3.lock();        try {            for (int i = 0; i < 5; i++) {               System.out.println(Thread.currentThread().getName()                      + ":synchronized in h()");               try {                   TimeUnit.SECONDS.sleep(3);               } catch (InterruptedException e) {                   e.printStackTrace();               }            }        } finally {            lock3.unlock();        }     }       public static void main(String[] args) {        final Resource4 rs = new Resource4();          new Thread() {            public void run() {               rs.f();            }        }.start();          new Thread() {            public void run() {               rs.g();            }        }.start();          rs.h();     } }

结果：
Thread-0:not synchronized in f()
Thread-0:synchronized in f()
main:not synchronized in h()
main:synchronized in h()
Thread-1:not synchronized in g()
Thread-1:synchronized in g()
Thread-0:synchronized in f()
main:synchronized in h()
Thread-1:synchronized in g()
Thread-0:synchronized in f()
main:synchronized in h()
Thread-1:synchronized in g()
Thread-0:synchronized in f()
main:synchronized in h()
Thread-1:synchronized in g()
Thread-0:synchronized in f()
main:synchronized in h()
Thread-1:synchronized in g()