java synchronized对象锁与类锁的区别、同步代码块与同步方法的区别

原创 2017年05月19日 23:34:14

终于搞明白synchronized的作用了,献上一篇,如下:

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

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

java的对象锁和类锁:java的对象锁和类锁在锁的概念上基本上和内置锁是一致的,但是,两个锁实际是有很大的区别的,对象锁是用于对象实例方法,
或者一个对象实例上的,类锁是用于类的静态方法或者一个类的class对象上的。我们知道,类的对象实例可以有很多个,但是每个类只有一个class对象,
所以不同对象实例的对象锁是互不干扰的,但是每个类只有一个类锁。但是有一点必须注意的是,其实类锁只是一个概念上的东西,并不是真实存在的,
它只是用来帮助我们理解锁定实例方法和静态方法的区别的。

public class TestSynchronized 
{  
    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 TestSynchronized myt2 = new TestSynchronized();  
         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();  
//         TestRunnable tr=new TestRunnable();
//         Thread test3=new Thread(tr);
//         test3.start();
    } 
}
 
test2 : 4
test2 : 3
test2 : 2
test2 : 1
test2 : 0
test1 : 4
test1 : 3
test1 : 2
test1 : 1
test1 : 0
public class TestSynchronized 
{  
    public void test1() 
    {  
         synchronized(TestSynchronized.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 TestSynchronized myt2 = new TestSynchronized();  
         Thread test1 = new Thread(  new Runnable() {  public void run() {  myt2.test1();  }  }, "test1"  );  
         Thread test2 = new Thread(  new Runnable() {  public void run() { TestSynchronized.test2();   }  }, "test2"  );  
         test1.start();  
         test2.start();  
//         TestRunnable tr=new TestRunnable();
//         Thread test3=new Thread(tr);
//         test3.start();
    } 
}
 

test1 : 4
test1 : 3
test1 : 2
test1 : 1
test1 : 0
test2 : 4
test2 : 3
test2 : 2
test2 : 1
test2 : 0
public class TestSynchronized 
{  
    public synchronized void test1() 
    {  
              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 TestSynchronized myt2 = new TestSynchronized();  
         Thread test1 = new Thread(  new Runnable() {  public void run() {  myt2.test1();  }  }, "test1"  );  
         Thread test2 = new Thread(  new Runnable() {  public void run() { TestSynchronized.test2();   }  }, "test2"  );  
         test1.start();  
         test2.start();  
//         TestRunnable tr=new TestRunnable();
//         Thread test3=new Thread(tr);
//         test3.start();
    } 
}
 

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


上面代码synchronized同时修饰静态方法和实例方法,但是运行结果是交替进行的,这证明了类锁和对象锁是两个不一样的锁,控制着不同的区域,它们是互不干扰的。同样,线程获得对象锁的同时,也可以获得该类锁,即同时获得两个锁,这是允许的。

这时如果直接用synchronized修饰调用了so.testsy();代码的方法,那么当某个线程进入了这个方法之后,这个对象其他同步方法都不能给其他线程访问了。假如这个方法需要执行的时间很长,那么其他线程会一直阻塞,影响到系统的性能。如果这时用synchronized来修饰代码块:synchronized(so){so.testsy();},那么这个方法加锁的对象是so这个对象,跟执行这行代码的对象没有关系,当一个线程执行这个方法时,这对其他同步方法时没有影响的,因为他们持有的锁都完全不一样。不过这里还有一种特例,就是上面演示的第一个例子,对象锁synchronized同时修饰方法和代码块,这时也可以体现到同步代码块的优越性,如果test1方法同步代码块后面有非常多没有同步的代码,而且有一个100000的循环,这导致test1方法会执行时间非常长,那么如果直接用synchronized修饰方法,那么在方法没执行完之前,其他线程是不可以访问test2方法的,但是如果用了同步代码块,那么当退出代码块时就已经释放了对象锁,当线程还在执行test1的那个100000的循环时,其他线程就已经可以访问test2方法了。这就让阻塞的机会或者线程更少。让系统的性能更优越。

public class Main {
	class Inner {
		private void m4t1() {
			int i = 5;
			while (i-- > 0) {
				System.out.println(Thread.currentThread().getName()
						+ " : Inner.m4t1()=" + i);
				try {
					Thread.sleep(500);
				} catch (InterruptedException ie) {
				}
			}
		}//m4t1

		private  synchronized void m4t2() {
			int i = 5;
			while (i-- > 0) {
				System.out.println(Thread.currentThread().getName()
						+ " : Inner.m4t2()=" + i);
				try {
					Thread.sleep(500);
				} catch (InterruptedException ie) {
				}
			}
		}//m4t2
	}//inner

	private void m4t1(Inner inner) {
		synchronized (inner) { // 使用对象锁
			inner.m4t1();
		}
	}

	private void m4t2(Inner inner) {
		inner.m4t2();
	}

	public static void main(String[] args) {
		final Main myt3 = new Main();
		final Inner inner = myt3.new Inner();
		Thread t1 = new Thread(new Runnable() {
			public void run() {
				myt3.m4t1(inner);
			}
		}, "t1");
		Thread t2 = new Thread(new Runnable() {
			public void run() {
				myt3.m4t2(inner);
			}
		}, "t2");
		t1.start();
		t2.start();
	}
}
//t1 : Inner.m4t1()=4
//t1 : Inner.m4t1()=3
//t1 : Inner.m4t1()=2
//t1 : Inner.m4t1()=1
//t1 : Inner.m4t1()=0
//t2 : Inner.m4t2()=4
//t2 : Inner.m4t2()=3
//t2 : Inner.m4t2()=2
//t2 : Inner.m4t2()=1
//t2 : Inner.m4t2()=0
public class SynObj{
    public synchronized void showA(){
        System.out.println("showA..");
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    
    public void showB(){
        synchronized (this) {
        	System.out.println(this.getClass().getSimpleName());
            System.out.println("showB..");
        }
    }
    
    public void showC(){
        String s="1";
        synchronized (s) {
            System.out.println("showC..");
        }
    }
}
public class Main {
    public static void main(String[] args) {
        final SynObj sy=new SynObj();
        new Thread(new Runnable() {
            
            @Override
            public void run() {
                sy.showA();
            }
        }).start();
        new Thread(new Runnable() {
            
            @Override
            public void run() {
                sy.showB();
            }
        }).start();
        new Thread(new Runnable() {
            
            @Override
            public void run() {
                sy.showC();
            }
        }).start();
    }
}

//showA..
//showC..
//SynObj
//showB..
这段代码的打印结果是,showA…..showC…..会很快打印出来,showB…..会隔一段时间才打印出来,那么showB为什么不能像showC那样很快被调用呢?
  在启动线程1调用方法A后,接着会让线程1休眠3秒钟,这时会调用方法C,注意到方法C这里用synchronized进行加锁,这里锁的对象是s这个字符串对象。
但是方法B则不同,是用当前对象this进行加锁,注意到方法A直接在方法上加synchronized,这个加锁的对象是什么呢?显然,这两个方法用的是一把锁。
  *由这样的结果,我们就知道这样同步方法是用什么加锁的了,由于线程1在休眠,这时锁还没释放,导致线程2只有在3秒之后才能调用方法B,
由此,可知两种加锁机制用的是同一个锁对象,即当前对象。 
  另外,同步方法直接在方法上加synchronized实现加锁,同步代码块则在方法内部加锁,很明显,同步方法锁的范围比较大,
而同步代码块范围要小点,一般同步的范围越大,性能就越差,一般需要加锁进行同步的时候,肯定是范围越小越好,这样性能更好*。

一、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时,一个时间内只能有一个线程得到执行。
另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。 
二、然而,当一个线程访问object的一个synchronized(this)同步代码块时,另一个线程仍然可以访问该object中的非synchronized(this)同步代码块。 
三、尤其关键的是,当一个线程访问object的一个synchronized(this)同步代码块时,其他线程对object中所有其它synchronized(this)同步代码块的访问将被阻塞。

对象锁和类锁可以同时获得,即两种方法可以同时运行,互不影响;

一种锁方法只能运行同时运行一个,同种其他的锁方法暂时阻塞,普通方法的运行不受限制

参考:

http://www.cnblogs.com/wl0000-03/p/5973039.html

http://www.cnblogs.com/xujingyang/p/6565606.html

http://blog.csdn.net/h_gao/article/details/52266950

http://blog.csdn.net/zhenwodefengcaii/article/details/54601098 












版权声明:本文为博主原创文章,转载请说明出处

Thrift原理简析(JAVA)

Apache Thrift是一个跨语言的服务框架,本质上为RPC,同时具有序列化、反序列化机制;当我们开发的service需要开放出去的时候,就会遇到跨语言调用的问题,JAVA语言开发了一个UserS...

[转]同步synchronized方法和代码块

原文链接:http://jimi68.iteye.com/blog/69061 打个比方:一个object就像一个大房子,大门永远打开。房子里有很多房间(也就是方法)。这些房间有上锁的(sy...

java中的synchronized(同步代码块和同步方法的区别)

问题的由来: 看到这样一个面试题: //下列两个方法有什么区别 public synchronized void method1(){}public void method2(){ syn...
  • H_Gao
  • H_Gao
  • 2016年08月21日 13:48
  • 20713

java中的synchronized(同步代码块和同步方法的区别)

问题的由来:看到这样一个面试题://下列两个方法有什么区别 public synchronized void method1(){}public void method2(){ synchroniz...

Java的synchronized的同步代码块和同步方法的区别

线程同步问题大都使用synchronized解决,有同步代码块和同步方法的两种方式,主要记一下这两种的区别 测试代码: 1 package com.xujingyang.testThread; ...
  • xjy9266
  • xjy9266
  • 2017年03月17日 18:43
  • 115

java中的synchronized(同步代码块和同步方法的区别)

本文转自:http://blog.csdn.net/h_gao/article/details/52266950 问题的由来: 看到这样一个面试题: //下列两个方法有什么区别 pu...

java多线程-多线程的安全问题-多线程同步代码块-锁Synchronized

通过分析,发现,打印出了0,-1,-2等错票 多线程的运行出现了安全问题 问题的原因: 当多条语句在操作同一个线程共享数据时,一个线程对多条语句只执行了一部分...

java个人学习笔记17(synchronized+同步函数+同步代码块+死锁)

1.同步函数:就是在函数上加上同步关键字(syschronized)进行修饰    同步函数使用的锁即this,调用该函数的对象(下面例子中的b)    同步有两种形式: 1)同步代码块 2)...

Android 同步代码块,synchronized加锁

以车站售票为例,多个线程不能同时买一张票,所以把买票这个代码块加锁,等待前面线程买好了,后面线程才能进入买票 class BuyTicket implements Runnable { pri...
  • Pansing
  • Pansing
  • 2015年07月13日 16:05
  • 2691

多线程---java同步方法和同步代码块的区别

同步代码块: [java] view plain copy package threads.ex1; class KitchenSync { private int[] intArra...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:java synchronized对象锁与类锁的区别、同步代码块与同步方法的区别
举报原因:
原因补充:

(最多只允许输入30个字)