Synchronized说:给我一把锁,我能创造一个规矩


以下总结摘自(加上一点自己的理解):http://blog.csdn.net/yangzhijun_cau/article/details/6432216

1.为什么有多线程同步?Java中多线程同步的机制是什么?

    当多个线程同时竞争同一资源时候,为了防止出现数据不一致性问题,需要有同步机制。而同步机制是通过锁的概念来实现的。


2.JVM对哪类线程共享的数据进行加锁机制?

   1)保存在堆中的实例变量---对象锁,就是有一个和对象相关联的监视器

    2)保存在方法区的类变量---类锁实际上用对象锁来实现,当JVM装载一个class文件时候,他会创建一个java.lang.class类的实例。所以类锁锁住的是那个类的Class对象。相应的也会有一个类对象监视器


3.何时上锁?

    这里对象锁是Java虚拟机内部使用,在Java程序中只要使用synchronized块或者synchronized方法就可以标志一个监视区域,当每次进入一个监视区域时,JVM都会自动锁上对象或者类。


4.多线程同步时,所持有的对象锁有什么要求?

   共享且唯一的


5.实例验证线程同步时,锁持有的是都为同一对象锁?只有是唯一共享的对象锁,多线程才能实现同步哦

//10个线程在控制台上数数,从1数到9999。理想情况下,我们希望看到一个线程数完,然后才是另一个线程开始数数。

实例1如下

public class ThreadTest extends Thread {   
    private int threadNo;   
    public ThreadTest(int threadNo) {   
        this.threadNo = threadNo;   
    }   
    public static void main(String[] args) throws Exception {   
        for (int i = 1; i < 10; i++) {   
           new ThreadTest(i).start();   
            Thread.sleep(1);   
        }   
     }   
    
    @Override  
     public synchronized void run() {   
        for (int i = 1; i < 10000; i++) {   
            System.out.println("No." + threadNo + ":" + i);   
        }   
     }   
 }   

结果程序并没有按照顺序报数。但是程序中已经使用了synchronized关键字了呀,这是怎么回事?首先这是一个ThreadTest实例对象锁,而在main方法中,共产生了十个实例对象,每个线程都持有自己对象的那个对象锁,因此不能实现同步效果。

实例2

public class ThreadTest2 extends Thread {   
 private int threadNo; private String lock;   
 public ThreadTest2(int threadNo, String lock) {   
  this.threadNo = threadNo;   
     this.lock = lock;   }   
public static void main(String[] args) throws Exception {   
   String lock = new String("lock");   
     for (int i = 1; i < 10; i++) {     
  new ThreadTest2(i, lock).start();   
      Thread.sleep(1);   
     }   
  }     
public void run() {     
 synchronized (lock) {   
      for (int i = 1; i < 10000; i++) {   
       System.out.println("No." + threadNo + ":" + i);   
    }      
 }     
 }   
 }  

       该程序通过在main方法启动10个线程之前,创建了一个String类型的对象(对象保存在堆中)。并通过ThreadTest2的构造函数,将这个对象赋值 给每一个ThreadTest2线程对象中的私有变量lock。根据Java方法的传值特点,我们知道,这些线程的lock变量实际上指向的是堆内存中的 同一个区域,即存放main函数中的lock变量的区域。
        程序将原来run方法前的synchronized关键字去掉,换用了run方法中的一个synchronized块来实现。这个同步块的对象锁,就是 main方法中创建的那个String对象。换句话说,他们指向的是同一个String类型的对象,对象锁是共享且唯一的!因此会看到顺序报数的结果。

实例3

 public class ThreadTest3 extends Thread {   

 2    
 3     private int threadNo;   
 4     private String lock;   
 5    
 6     public ThreadTest3(int threadNo) {   
 7         this.threadNo = threadNo;   
 8     }   
 9    
10     public static void main(String[] args) throws Exception {   
11        
12         for (int i = 1; i < 20; i++) {   
13             new ThreadTest3(i).start();   
14             Thread.sleep(1);   
15         }   
16     }   
17    
18     public static synchronized void abc(int threadNo) {   
19         for (int i = 1; i < 10000; i++) {   
20               
21                 System.out.println("No." + threadNo + ":" + i);           
22         }   
23     }   
24    
25     public void run() {   
36         abc(threadNo);   
27     }   
28 }  
同样,程序能按照顺序报数。这段代码没有使用main方法中创建的String对象作为这10个线程的线程锁。而是通过在run方法中调用本线程中一个静态的同步方法abc而实现了线程的同步。这里synchroniaed静态方法是用类实例(唯一)来做对象锁的。


于是,对于synchronized我们知道:

1、对于同步的方法或者代码块来说,必须获得对象锁才能够进入同步方法或者代码块进行操作;
2、如果采用method级别的同步,则对象锁即为method所在的对象,如果是静态方法,对象锁即指method所在的Class对象(唯一);
3、对于代码块,对象锁即指synchronized(abc)中的abc;
4、对于第一种情况,对象锁即为每一个线程对象,因此有多个,所以同步失效,第二种共用同一个对象锁lock,因此同步生效,第三个因为是static,因此对象锁为ThreadTest3的class 对象,因此同步生效。

如上述正确,则同步有两种方式,同步块和同步方法

如果是同步代码块,则对象锁需要编程人员自己指定,一般有些代码为synchronized(this)只有在单态模式才生效;(本类的实例有且只有一个)

如果是同步方法,则分静态和非静态两种 。

静态方法则一定会同步,非静态方法需在单例模式才生效,推荐用静态方法(不用担心是否单例)。

在Java多线程编程中,最常见的synchronized关键字实际上是依靠对象锁的机制来实现线程同步的。



评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值