对于Synchronized学习了多次,但是有时候还是不理解其中的区别,找了很久的材料,才对Synchronized有较深的理解。
1.Synchronized相关概念
在Java编程中,经常会用到同步,而用的最多也许就是Synchronized这个关键字。首先Synchronized关键字涉及到锁的概念。首先对相关概念进行解释。先借用别人的总结,感觉还不错!!!!
java的内置锁:每个java对象都可以用做一个实现同步的锁,这些锁成为内置锁。线程进入同步代码块或方法的时候会自动获得该锁,在退出同步代码块或方法时会释放该锁。获得内置锁的唯一途径就是进入这个锁的保护的同步代码块或方法。
java内置锁是一个互斥锁,这就是意味着最多只有一个线程能够获得该锁,当线程A尝试去获得线程B持有的内置锁时,线程A必须等待或者阻塞,知道线程B释放这个锁,如果B线程不释放这个锁,那么A线程将永远等待下去。
java的对象锁和类锁:java的对象锁和类锁在锁的概念上基本上和内置锁是一致的,但是,两个锁实际是有很大的区别的,对象锁是用于对象实例方法,或者一个对象实例上的,类锁是用于类的静态方法或者一个类的class对象上的。我们知道,类的对象实例可以有很多个,但是每个类只有一个class对象,所以不同对象实例的对象锁是互不干扰的,但是每个类只有一个类锁。但是有一点必须注意的是,其实类锁只是一个概念上的东西,并不是真实存在的,它只是用来帮助我们理解锁定实例方法和静态方法的区别的。
2.对象锁
通过以上相关概念的描述,对Synchronized关键字有了初步的理解,从中可以的出Synchronized的用法:Synchronized修饰方法和Synchronized修饰代码块。为了加深相关概念,通过一段实例加深对相关概念的理解。
public class SynchronizedTest
{
public void test1()
{
synchronized(this)
{
int i = 5;
while( i-- > 0)
{
System.out.println(Thread.currentThread().getName() + " : " + i);
try
{
Thread.sleep(500);
}
catch (InterruptedException ie)
{
}
}
}
}
public synchronized void test2()
{
int i = 5;
while( i-- > 0)
{
System.out.println(Thread.currentThread().getName() + " : " + i);
try
{
Thread.sleep(500);
}
catch (InterruptedException ie)
{
}
}
}
public static void main(String[] args)
{
final SynchronizedTest myt2 = new SynchronizedTest();
Thread test1 = new Thread( new Runnable() { public void run() { myt2.test1(); } }, "test1" );
Thread test2 = new Thread( new Runnable() { public void run() { myt2.test2(); } }, "test2" );
test1.start();
test2.start();
}
}
上述方法代码中,第一个方法使用了同步代码块的方式进行同步,传入的是对象实例this,表示是当前对象,当然,如果需要同步其他对象,也可以传入其他对象的实例。第二个方法是修饰方法的方式进行同步。其运行结果如下:
因为第一个同步块传入的是this,所以两个同步块代码需要获得的对象锁是同一个对象锁,下面main方法是同时开启两个线程,分别调用test1和test2的方法,那么两个线程都需要获得该对象锁,一个获得之后,另一个线程必须等到哪一个线程结束之后,才能得到线程锁。从结果中我们也可以看出:test2线程结束之后,释放锁,test1线程才开始运行。可能有人会疑问,代码里明明是先开启的test1线程,为什么先执行的是test2线程呢?这是因为java编译器在编译成字节码的时候,会对代码进行一个重排序,也就是说,编译器会根据实际情况对代码进行一个合理的排序,编译前代码写在前面,在编译后的字节码不一定排在前面,所以这种运行结果是正常的, 这里是题外话,最主要是检验synchronized的用法的正确性。
如果我们把test1方法的Synchronized(this)去掉,改在方法上呢?
package SynchronizedTest;
public class SynchronizedTest
{
public synchronized void test1()
{
/*synchronized(this) */
{
int i = 5;
while( i-- > 0)
{
System.out.println(Thread.currentThread().getName() + " : " + i);
try
{
Thread.sleep(500);
}
catch (InterruptedException ie)
{
}
}
}
}
public synchronized void test2()
{
int i = 5;
while( i-- > 0)
{
System.out.println(Thread.currentThread().getName() + " : " + i);
try
{
Thread.sleep(500);
}
catch (InterruptedException ie)
{
}
}
}
public static void main(String[] args)
{
final SynchronizedTest myt2 = new SynchronizedTest();
Thread test1 = new Thread( new Runnable() { public void run() { myt2.test1(); } }, "test1" );
Thread test2 = new Thread( new Runnable() { public void run() { myt2.test2(); } }, "test2" );
test1.start();
test2.start();
}
}
运行结果如下,你会发现和上图运行的结果是一样的。从而进一步说明了对象锁的概念。
当我们把test2方法中的Synchronized去掉将会如何呢?
上面是执行结果,我们可以看到,结果输出是交替着进行输出的,这是因为,某个线程得到了对象锁,但是另一个线程还是可以访问没有进行同步的方法或者代码。进行了同步的方法(加锁方法)和没有进行同步的方法(普通方法)是互不影响的,一个线程进入了同步方法,得到了对象锁,其他线程还是可以访问那些没有同步的方法(普通方法)。这里涉及到内置锁的一个概念(此概念出自java并发编程实战第二章):对象的内置锁和对象的状态之间是没有内在的关联的,虽然大多数类都将内置锁用做一种有效的加锁机制,但对象的域并不一定通过内置锁来保护。当获取到与对象关联的内置锁时,并不能阻止其他线程访问该对象,当某个线程获得对象的锁之后,只能阻止其他线程获得同一个锁。之所以每个对象都有一个内置锁,是为了免去显式地创建锁对象。
当创建多个对象时,结果又将如何呢?
package SynchronizedTest;
public class SynchronizedTest
{
public void test1()
{
synchronized(this)
{
int i = 5;
while( i-- > 0)
{
System.out.println(Thread.currentThread().getName() + " : " + i);
try
{
Thread.sleep(500);
}
catch (InterruptedException ie)
{
}
}
}
}
public synchronized void test2()
{
int i = 5;
while( i-- > 0)
{
System.out.println(Thread.currentThread().getName() + " : " + i);
try
{
Thread.sleep(500);
}
catch (InterruptedException ie)
{
}
}
}
public static void main(String[] args)
{
final SynchronizedTest myt2 = new SynchronizedTest();
final SynchronizedTest myt3 = new SynchronizedTest();
final SynchronizedTest myt4 = new SynchronizedTest();
Thread test1 = new Thread( new Runnable() { public void run() { myt2.test1(); } }, "test1" );
Thread test2 = new Thread( new Runnable() { public void run() { myt2.test2(); } }, "test2" );
Thread test3 = new Thread( new Runnable() { public void run() { myt3.test1(); } }, "test3" );
Thread test4 = new Thread( new Runnable() { public void run() { myt3.test2(); } }, "test4" );
Thread test5 = new Thread( new Runnable() { public void run() { myt4.test1(); } }, "test5" );
Thread test6 = new Thread( new Runnable() { public void run() { myt4.test2(); } }, "test6" );
test1.start();
test2.start();
test3.start();
test4.start();
test5.start();
test6.start();
}
}
其运行结果如下:
实例中有三个不同的对象,六种线程。test1线程和test2线程共享对象myt2;test3线程和test4线程共享对象myt3;test5线程和test6线程共享对象myt4;从结果中得出不同对象实例myt2、myt3、myt4的线程交替进行输出,说明不同对象实例的对象锁是互不干扰。同时你也会发现,先运行myt2的test1线程、myt3的test3线程、myt4的test5线程,然后运行myt2的test2线程、myt3的test4线程、myt4的test6线程.当某一个对象的对象锁被占有之后,这个对象的另一个线程就会等当前运行线程结束,释放对象锁之后才会运行。
3.类锁的修饰方法或者代码块
为详细了解类锁,先看一段代码及其运行结果:
package SynchronizedTest;
public class SynchronizedTest
{
public void test1()
{
synchronized(SynchronizedTest.class)
{
int i = 5;
while( i-- > 0)
{
System.out.println(Thread.currentThread().getName() + " : " + i);
try
{
Thread.sleep(500);
}
catch (InterruptedException ie)
{
}
}
}
}
public static synchronized void test2()
{
int i = 5;
while( i-- > 0)
{
System.out.println(Thread.currentThread().getName() + " : " + i);
try
{
Thread.sleep(500);
}
catch (InterruptedException ie)
{
}
}
}
public static void main(String[] args)
{
final SynchronizedTest myt2 = new SynchronizedTest();
/*final SynchronizedTest myt3 = new SynchronizedTest();
final SynchronizedTest myt4 = new SynchronizedTest();*/
Thread test1 = new Thread( new Runnable() { public void run() { myt2.test1(); } }, "test1" );
Thread test2 = new Thread( new Runnable() { public void run() { myt2.test2(); } }, "test2" );
/*Thread test3 = new Thread( new Runnable() { public void run() { myt3.test1(); } }, "test3" );
Thread test4 = new Thread( new Runnable() { public void run() { myt3.test2(); } }, "test4" );
Thread test5 = new Thread( new Runnable() { public void run() { myt4.test1(); } }, "test5" );
Thread test6 = new Thread( new Runnable() { public void run() { myt4.test2(); } }, "test6" );*/
test1.start();
test2.start();
/* test3.start();
test4.start();
test5.start();
test6.start(); */
}
}其
其运行结果如下:
你会发现他的运行结果和对象锁是一样的,这分辨不出其中的差别。
当出现不同对象实例又当如何呢?
final SynchronizedTest myt2 = new SynchronizedTest();
final SynchronizedTest myt3 = new SynchronizedTest();
final SynchronizedTest myt4 = new SynchronizedTest();
Thread test1 = new Thread( new Runnable() { public void run() { myt2.test1(); } }, "test1" );
Thread test2 = new Thread( new Runnable() { public void run() { myt2.test2(); } }, "test2" );
Thread test3 = new Thread( new Runnable() { public void run() { myt3.test1(); } }, "test3" );
Thread test4 = new Thread( new Runnable() { public void run() { myt3.test2(); } }, "test4" );
Thread test5 = new Thread( new Runnable() { public void run() { myt4.test1(); } }, "test5" );
Thread test6 = new Thread( new Runnable() { public void run() { myt4.test2(); } }, "test6" );
test1.start();
test2.start();
test3.start();
test4.start();
test5.start();
test6.start();
其运行结果如下:
从结果可以分析得出,类锁是一个类独一无二的,不管这一个类有多少个实例,他的类锁只有一个。当一个类中有很多个线程,对类锁而言,他只能一个线程运行结束之后,释放类锁之后,另一个线程才能运行。
synchronized同时修饰静态和非静态方法时结果又当如何呢?
package SynchronizedTest;
public class SynchronizedTest
{
public synchronized void test1()
{
/*synchronized(SynchronizedTest.class)*/
{
int i = 5;
while( i-- > 0)
{
System.out.println(Thread.currentThread().getName() + " : " + i);
try
{
Thread.sleep(500);
}
catch (InterruptedException ie)
{
}
}
}
}
public static synchronized void test2()
{
int i = 5;
while( i-- > 0)
{
System.out.println(Thread.currentThread().getName() + " : " + i);
try
{
Thread.sleep(500);
}
catch (InterruptedException ie)
{
}
}
}
public static void main(String[] args)
{
final SynchronizedTest myt2 = new SynchronizedTest();
/*final SynchronizedTest myt3 = new SynchronizedTest();
final SynchronizedTest myt4 = new SynchronizedTest();*/
Thread test1 = new Thread( new Runnable() { public void run() { myt2.test1(); } }, "test1" );
Thread test2 = new Thread( new Runnable() { public void run() { myt2.test2(); } }, "test2" );
/*Thread test3 = new Thread( new Runnable() { public void run() { myt3.test1(); } }, "test3" );
Thread test4 = new Thread( new Runnable() { public void run() { myt3.test2(); } }, "test4" );
Thread test5 = new Thread( new Runnable() { public void run() { myt4.test1(); } }, "test5" );
Thread test6 = new Thread( new Runnable() { public void run() { myt4.test2(); } }, "test6" );*/
test1.start();
test2.start();
/* test3.start();
test4.start();
test5.start();
test6.start(); */
}
}
运行结果如下:
上面代码synchronized同时修饰静态方法和实例方法,但是运行结果是交替进行的,这证明了类锁和对象锁是两个不一样的锁,控制着不同的区域,它们是互不干扰的。同样,线程获得对象锁的同时,也可以获得该类锁,即同时获得两个锁,这是允许的。
当出现多个实例之后,又当如何呢?
package SynchronizedTest;
public class SynchronizedTest
{
public synchronized void test1()
{
/*synchronized(SynchronizedTest.class)*/
{
int i = 5;
while( i-- > 0)
{
System.out.println(Thread.currentThread().getName() + " : " + i+" 对象锁被占用--");
try
{
Thread.sleep(500);
}
catch (InterruptedException ie)
{
}
}
}
}
public static synchronized void test2()
{
int i = 5;
while( i-- > 0)
{
System.out.println(Thread.currentThread().getName() + " : " + i+" 类锁占用+++");
try
{
Thread.sleep(500);
}
catch (InterruptedException ie)
{
}
}
}
public static void main(String[] args)
{
final SynchronizedTest myt2 = new SynchronizedTest();
final SynchronizedTest myt3 = new SynchronizedTest();
final SynchronizedTest myt4 = new SynchronizedTest();
Thread test1 = new Thread( new Runnable() { public void run() { myt2.test1(); } }, "test1" );
Thread test2 = new Thread( new Runnable() { public void run() { myt2.test2(); } }, "test2" );
Thread test3 = new Thread( new Runnable() { public void run() { myt3.test1(); } }, "test3" );
Thread test4 = new Thread( new Runnable() { public void run() { myt3.test2(); } }, "test4" );
Thread test5 = new Thread( new Runnable() { public void run() { myt4.test1(); } }, "test5" );
Thread test6 = new Thread( new Runnable() { public void run() { myt4.test2(); } }, "test6" );
test1.start();
test2.start();
test3.start();
test4.start();
test5.start();
test6.start();
}
}
运行结果如下:
通过这个结果,可以得出分析:1.这证明了类锁和对象锁是两个不一样的锁,控制着不同的区域,它们是互不干扰的。同样,线程获得对象锁的同时,也可以获得该类锁,即同时获得两个锁,这是允许的。
2.一个对象的线程,如果他的一个线程运行的是类锁,那么就不能运行对象锁,myt2下的线程test1、myt3下的线程test3、myt4下的线程test5运行的是对象锁。则其他运行的是类锁。
4.问题发现:
到这里,对synchronized的用法已经有了一定的了解。这时有一个疑问,既然有了synchronized修饰方法的同步方式,为什么还需要synchronized修饰同步代码块的方式呢?而这个问题也是synchronized的缺陷所在
synchronized的缺陷:当某个线程进入同步方法获得对象锁,那么其他线程访问这里对象的同步方法时,必须等待或者阻塞,这对高并发的系统是致命的,这很容易导致系统的崩溃。如果某个线程在同步方法里面发生了死循环,那么它就永远不会释放这个对象锁,那么其他线程就要永远的等待。这是一个致命的问题。
当然同步方法和同步代码块都会有这样的缺陷,只要用了synchronized关键字就会有这样的风险和缺陷。既然避免不了这种缺陷,那么就应该将风险降到最低。这也是同步代码块在某种情况下要优于同步方法的方面。例如在某个类的方法里面:这个类里面声明了一个对象实例,SynObject so=new SynObject();在某个方法里面调用了这个实例的方法so.testsy();但是调用这个方法需要进行同步,不能同时有多个线程同时执行调用这个方法。
这时如果直接用synchronized修饰调用了so.testsy();代码的方法,那么当某个线程进入了这个方法之后,这个对象其他同步方法都不能给其他线程访问了。假如这个方法需要执行的时间很长,那么其他线程会一直阻塞,影响到系统的性能。
如果这时用synchronized来修饰代码块:synchronized(so){so.testsy();},那么这个方法加锁的对象是so这个对象,跟执行这行代码的对象没有关系,当一个线程执行这个方法时,这对其他同步方法时没有影响的,因为他们持有的锁都完全不一样。
不过这里还有一种特例,就是上面演示的第一个例子,对象锁synchronized同时修饰方法和代码块,这时也可以体现到同步代码块的优越性,如果test1方法同步代码块后面有非常多没有同步的代码,而且有一个100000的循环,这导致test1方法会执行时间非常长,那么如果直接用synchronized修饰方法,那么在方法没执行完之前,其他线程是不可以访问test2方法的,但是如果用了同步代码块,那么当退出代码块时就已经释放了对象锁,当线程还在执行test1的那个100000的循环时,其他线程就已经可以访问test2方法了。这就让阻塞的机会或者线程更少。让系统的性能更优越。
一个类的对象锁和另一个类的对象锁是没有关联的,当一个线程获得A类的对象锁时,它同时也可以获得B类的对象锁。