这篇文章主要为大家展示了“Java编程之Synchronized锁住对象的示例分析”，内容简而易懂，条理清晰，希望能够帮助大家解决疑惑，下面让小编带领大家一起研究并学习一下“Java编程之Synchronized锁住对象的示例分析”这篇文章吧。

创新互联坚持“要么做到，要么别承诺”的工作理念，服务领域包括：成都做网站、网站制作、成都外贸网站建设、企业官网、英文网站、手机端网站、网站推广等服务，满足客户于互联网时代的肃北网站设计、移动媒体设计的需求，帮助企业找到有效的互联网解决方案。努力成为您成熟可靠的网络建设合作伙伴！

密码修改为  synchronized是java中用于同步的关键字，一般我们通过Synchronized锁住一个对象，来进行线程同步。我们需要了解在程序执行过程中，synchronized锁住的到底是哪个对象，否则我们在多线程的程序就有可能出现问题。

看下面的代码，我们定义了一个静态变量n,在run方法中，我们使n增加10，然后在main方法中，我们开辟了100个线程，来执行n增加的操作，如果线程没有并发执行，那么n最后的值应该为1000，显然下面的程序执行完结果不是1000，因为我们没有进行线程同步。

import java.util.concurrent.TimeUnit; 
public class SynchronizedTest1 extends Thread { 
  public static int n = 0; 
  public void run() { 
    try { 
      //使n自加10次 
      for (int i = 0; i < 10; i++) { 
        n = n + 1; 
        TimeUnit.MILLISECONDS.sleep(10); 
      } 
    } catch (InterruptedException e) { 
      e.printStackTrace(); 
    } 
  } 
  public static void main(String[] args) throws InterruptedException { 
    Thread[] threads = new Thread[100]; 
    for (int i = 0; i < threads.length; i++) { 
      threads[i] = new SynchronizedTest1(); 
      threads[i].start(); 
    } 
    //使所有其他线程执行完，再继续执行main线程,这样得出的n是最终的结果 
    for (Thread thread : threads) { 
      thread.join(); 
    } 
    System.out.println(n); 
  } 
}

为了实现同步，我们修改上面的代码，增加一个increase方法，如下。但是当我们执行下面的代码时，会发现n仍然不是1000.

import java.util.concurrent.TimeUnit; 
public class SynchronizedTest2 extends Thread { 
  public static int n = 0; 
  public synchronized void increase() { 
    n++; 
  } 
  public void run() { 
    try { 
      //使n自加10次 
      for (int i = 0; i < 10; i++) { 
        increase(); 
        TimeUnit.MILLISECONDS.sleep(10); 
      } 
    } catch (InterruptedException e) { 
      e.printStackTrace(); 
    } 
  } 
  public static void main(String[] args) throws InterruptedException { 
    Thread[] threads = new Thread[100]; 
    for (int i = 0; i < threads.length; i++) { 
      threads[i] = new SynchronizedTest2(); 
      threads[i].start(); 
    } 
    //使所有其他线程执行完，再继续执行main线程,这样得出的n是最终的结果 
    for (Thread thread : threads) { 
      thread.join(); 
    } 
    System.out.println(n); 
  } 
}

其实原因很简单，上面的多个线程在执行时根本就没有竞争同一个对象锁。当我们执行用synchronized修饰的非静态方法时，线程会首先获得调用这个方法的对象的锁，然后才能继续执行代码。那么调用这个方法的到底是哪个对象，是this对象。在上面的例子中，thread[i]所代表的线程获取的锁对象是thread[i]对象，也就是该线程对象本身。因此上面所开辟的100个线程只要获得自身对象就可以执行，这样就使同步失去了作用。

我们再次修改代码：即将increase方法改为i静态的，此时程序执行完后n的值为1000。

import java.util.concurrent.TimeUnit; 
 
public class SynchronizedTest3 extends Thread { 
  public static int n = 0; 
 
  public synchronized static void increase() { 
    n++; 
  } 
  public void run() { 
    try { 
      //使n自加10次 
      for (int i = 0; i < 10; i++) { 
        increase(); 
        TimeUnit.MILLISECONDS.sleep(10); 
      } 
    } catch (InterruptedException e) { 
      e.printStackTrace(); 
    } 
  } 
 
  public static void main(String[] args) throws InterruptedException { 
    Thread[] threads = new Thread[100]; 
    for (int i = 0; i < threads.length; i++) { 
      threads[i] = new SynchronizedTest3(); 
      threads[i].start(); 
    } 
 
    //使所有其他线程执行完，再继续执行main线程,这样得出的n是最终的结果 
    for (Thread thread : threads) { 
      thread.join(); 
    } 
    System.out.println(n); 
  } 
}

当synchronized 修饰static方法，它锁住的是该类的Class对象，而不是某一个具体对象。在上面的例子中，它锁住的就是SynchronizedTest3.class对象。在程序执行过程中，类的Class对象只有一份，所以上面线程竞争的是同一个对象锁。

下面是对synchronized锁住对象的总结：

（1）对于同步方法，锁当前对象（this）
（2）对于静态同步方法，锁当前类的Class对象
（3）对于同步代码块，锁住的是synchronized括号中的对象

以上是“Java编程之Synchronized锁住对象的示例分析”这篇文章的所有内容，感谢各位的阅读！相信大家都有了一定的了解，希望分享的内容对大家有所帮助，如果还想学习更多知识，欢迎关注创新互联行业资讯频道！

当前标题：Java编程之Synchronized锁住对象的示例分析
分享路径：http://myzitong.com/article/iggeds.html