java的同步_java的同步实现

最新推荐文章于 2024-07-15 08:12:25 发布

036015

最新推荐文章于 2024-07-15 08:12:25 发布

阅读量78

点赞数

文章标签： java的同步

本文链接：https://blog.csdn.net/weixin_32512451/article/details/114408941

版权

在java编程中，经常需要用到同步，而同步的实现使用最多的就是synchronized关键字了。

synchronized关键字涉及到“锁”的概念，首先先了解一下相关锁的知识。

java的内置锁：每个java对象都可以用做一个实现同步的锁，这些锁成为内置锁。线程进入同步代码块或方法的时候会自动获得该锁，在退出同步代码块或方法时会释放该锁。获得内置锁的唯一途径就是进入这个锁的保护的同步代码块或方法。

java内置锁是一个互斥锁，这就是意味着最多只有一个线程能够获得该锁，当线程A尝试去获得线程B持有的内置锁时，线程A必须等待或者阻塞，直到线程B释放这个锁，如果B线程不释放这个锁，那么A线程将永远等待下去。

java中的锁按级别可分为：对象锁或方法锁，类锁这两种。

java的对象锁(或方法锁)和类锁在锁的概念上与内置锁基本一致，但对象锁和类锁之间是有很大区别的。

区别：1、对象锁用于对象实例方法，类锁是用于类的静态方法或者一个类的class对象上。

2、类的对象可以有多个，所以不同的对象实例可以有多个对象锁，且互不干扰。每个类只有一个class对象，所以每个类只有一个类锁。

synchronized的用法：synchronized修改方法或者synchronized修饰代码块。

下面通过具体实例分析两种用法在对象锁和类锁上区别：

对象锁的synchronized修饰方法和代码块：

public classTestSynchronizedForObjectLock {public voidtest1(){synchronized(this){int i=5;while(i-- > 0){

System.out.println(Thread.currentThread().getName()+ ":" +i);try{

Thread.sleep(500);

}catch(InterruptedException e) {//TODO Auto-generated catch block

e.printStackTrace();

}

}public synchronized voidtest2(){int i =5;while(i-- > 0){

System.out.println(Thread.currentThread().getName()+ ":" +i);try{

Thread.sleep(500);

}catch(InterruptedException e) {//TODO Auto-generated catch block

e.printStackTrace();

}

}public static voidmain(String[] args) {

TestSynchronizedForObjectLock t= newTestSynchronizedForObjectLock();

Thread t1= new Thread(new Runnable(){public void run(){t.test1();}},"test1");

Thread t2= new Thread(new Runnable(){public void run(){t.test2();}},"test2");

t1.start();

t2.start();

}

其运行结果：

test1:4test1:3test1:2test1:1test1:0test2:4test2:3test2:2test2:1test2:0

上述的代码，第一个方法时用了同步代码块的方式进行同步，传入的对象实例是this，表明是当前对象；第二个方法是修饰方法的方式进行同步。因为第一个同步代码块传入的this，所以两个同步代码所需要获得的对象锁都是同一个对象锁，下面main方法时分别开启两个线程，分别调用test1和test2方法，那么两个线程都需要获得该对象锁，另一个线程必须等待。上面也给出了运行的结果可以看到：直到test1线程执行完毕，释放掉锁，test2线程才开始执行。

如果我们把test2方法的synchronized关键字去掉，执行结果会如何呢？运行结果：

test1:4test2:4test2:3test1:3test2:2test1:2test2:1test1:1test2:0test1:0

上面是执行结果，我们可以看到，结果输出是交替着进行输出的，这是因为，某个线程得到了对象锁，但是另一个线程还是可以访问没有进行同步的方法或者代码。进行了同步的方法(加锁方法)和没有进行同步的方法(普通方法)是互不影响的，一个线程进入了同步方法，得到了对象锁，其他线程还是可以访问那些没有同步的方法(普通方法)。

所以synchronized只是一个内置锁的加锁机制，当某个方法加上synchronized关键字后，就表明要获得该内置锁才能执行，并不能阻止其他线程访问不需要获得该内置锁的方法。

类锁的synchronized修饰方法和代码块：

public classTestSynchronizedForClassLock {public voidtest3(){synchronized(this.getClass()){int i=5;while(i-- > 0){

System.out.println(Thread.currentThread().getName()+ ":" +i);try{

Thread.sleep(500);

}catch(InterruptedException e) {//TODO Auto-generated catch block

e.printStackTrace();

}

}public static synchronized voidtest4(){int i=5;while(i-- > 0){

System.out.println(Thread.currentThread().getName()+ ":" +i);try{

Thread.sleep(500);

}catch(InterruptedException e) {//TODO Auto-generated catch block

e.printStackTrace();

}

}public static voidmain(String[] args) {

TestSynchronizedForClassLock c= newTestSynchronizedForClassLock();

Thread t3= new Thread(new Runnable(){public voidrun(){c.test3();}});

Thread t4= new Thread(new Runnable(){public voidrun(){TestSynchronizedForClassLock.test4();}});

t3.start();

t4.start();

}

运行结果：

Thread-0:4Thread-0:3Thread-0:2Thread-0:1Thread-0:0Thread-1:4Thread-1:3Thread-1:2Thread-1:1Thread-1:0

其实，类锁修饰方法和代码块的效果和对象锁是一样的，因为类锁只是一个抽象出来的概念，只是为了区别静态方法的特点，因为静态方法是所有对象实例共用的，所以对应着synchronized修饰的静态方法的锁也是唯一的，所以抽象出来个类锁。其实这里的重点在下面这块代码，synchronized同时修饰静态和非静态方法：

public classTestSynchronizedForClassLock {public synchronized voidtest3(){int i=5;while(i-- > 0){

System.out.println(Thread.currentThread().getName()+ ":" +i);try{

Thread.sleep(500);

}catch(InterruptedException e) {//TODO Auto-generated catch block

e.printStackTrace();

}

}public static synchronized voidtest4(){int i=5;while(i-- > 0){

System.out.println(Thread.currentThread().getName()+ ":" +i);try{

Thread.sleep(500);

}catch(InterruptedException e) {//TODO Auto-generated catch block

e.printStackTrace();

}