`

Java 多线程同步问题的探究（二、给我一把锁，我能创造一个规矩)

    博客分类：
  • JAVA
多线程Javathread编程.net 
阅读更多

在上一篇中，我们讲到了多线程是如何处理共享资源的，以及保证他们对资源进行互斥访问所依赖的重要机制：对象锁。

本篇中，我们来看一看传统的同步实现方式以及这背后的原理。

很多人都知道，在Java多线程编程中，有一个重要的关键字，synchronized。但是很多人看到这个东西会感到困惑：“都说同步机制是通过对象锁来实现的，但是这么一个关键字，我也看不出来Java程序锁住了哪个对象阿？“

没错，我一开始也是对这个问题感到困惑和不解。不过还好，我们有下面的这个例程：

 

Java代码 复制代码
  1. public class ThreadTest extends Thread {   
  2.   
  3.     
  4.   
  5.     private int threadNo;   
  6.   
  7.     
  8.   
  9.      public ThreadTest(int threadNo) {   
  10.   
  11.          this.threadNo = threadNo;   
  12.   
  13.      }   
  14.   
  15.     
  16.   
  17.      public static void main(String[] args) throws Exception {   
  18.   
  19.          for (int i = 1; i < 10; i++) {   
  20.   
  21.              new ThreadTest(i).start();   
  22.   
  23.              Thread.sleep(1);   
  24.   
  25.          }   
  26.   
  27.      }   
  28.   
  29.     
  30.   
  31.     @Override  
  32.   
  33.     public synchronized void run() {   
  34.   
  35.         for (int i = 1; i < 10000; i++) {   
  36.   
  37.              System.out.println("No." + threadNo + ":" + i);   
  38.   
  39.          }   
  40.   
  41.      }   
  42.   
  43.  }  
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);

         }

     }

 }

 这个程序其实就是让10个线程在控制台上数数，从1数到9999。理想情况下，我们希望看到一个线程数完，然后才是另一个线程开始数数。但是这个程序的执行过程告诉我们，这些线程还是乱糟糟的在那里抢着报数，丝毫没有任何规矩可言。

但是细心的读者注意到：run方法还是加了一个synchronized关键字的，按道理说，这些线程应该可以一个接一个的执行这个run方法才对阿。

但是通过上一篇中，我们提到的，对于一个成员方法加synchronized关键字，这实际上是以这个成员方法所在的对象本身作为对象锁。在本例中，就是以ThreadTest类的一个具体对象，也就是该线程自身作为对象锁的。一共十个线程，每个线程持有自己 线程对象的那个对象锁。这必然不能产生同步的效果。换句话说，如果要对这些线程进行同步，那么这些线程所持有的对象锁应当是共享且唯一的！

我们来看下面的例程：

 

Java代码 复制代码
  1. public class ThreadTest2 extends Thread {   
  2.   
  3.     
  4.   
  5.      private int threadNo;   
  6.   
  7.      private String lock;   
  8.   
  9.     
  10.   
  11.      public ThreadTest2(int threadNo, String lock) {   
  12.   
  13.          this.threadNo = threadNo;   
  14.   
  15.          this.lock = lock;   
  16.   
  17.      }   
  18.   
  19.     
  20.   
  21.      public static void main(String[] args) throws Exception {   
  22.   
  23.          String lock = new String("lock");   
  24.   
  25.          for (int i = 1; i < 10; i++) {   
  26.   
  27.              new ThreadTest2(i, lock).start();   
  28.   
  29.             Thread.sleep(1);   
  30.   
  31.          }   
  32.   
  33.      }   
  34.   
  35.     
  36.   
  37.      public void run() {   
  38.   
  39.          synchronized (lock) {   
  40.   
  41.              for (int i = 1; i < 10000; i++) {   
  42.   
  43.                 System.out.println("No." + threadNo + ":" + i);   
  44.   
  45.              }   
  46.   
  47.          }   
  48.   
  49.      }   
  50.   
  51. }  
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变量的区域。转载注明出处：http://x-spirit.iteye.com/、http: //www.blogjava.net/zhangwei217245/
转载注明出处：http://x-spirit.iteye.com/、http: //www.blogjava.net/zhangwei217245/
程序将原来run方法前的synchronized关键字去掉，换用了run方法中的一个synchronized块来实现。这个同步块的对象锁，就是 main方法中创建的那个String对象。换句话说，他们指向的是同一个String类型的对象，对象锁是共享且唯一的！转载注明出处：http://x-spirit.iteye.com/、http: //www.blogjava.net/zhangwei217245/

于是，我们看到了预期的效果：10个线程不再是争先恐后的报数了，而是一个接一个的报数。

再来看下面的例程：

 

Java代码 复制代码
  1. public class ThreadTest3 extends Thread {   
  2.   
  3.     
  4.   
  5.      private int threadNo;   
  6.   
  7.     private String lock;   
  8.   
  9.   
  10.   
  11.      public ThreadTest3(int threadNo) {   
  12.   
  13.          this.threadNo = threadNo;   
  14.   
  15.      }   
  16.   
  17.   
  18.   
  19.      public static void main(String[] args) throws Exception {   
  20.   
  21.          //String lock = new String("lock");   
  22.   
  23.          for (int i = 1; i < 20; i++) {   
  24.   
  25.              new ThreadTest3(i).start();   
  26.   
  27.              Thread.sleep(1);   
  28.   
  29.         }   
  30.   
  31.      }   
  32.   
  33.      public static synchronized void abc(int threadNo) {   
  34.   
  35.          for (int i = 1; i < 10000; i++) {   
  36.               
  37.                 System.out.println("No." + threadNo + ":" + i);   
  38.                    
  39.          }   
  40.   
  41.      }   
  42.   
  43.     
  44.   
  45.      public void run() {   
  46.   
  47.          abc(threadNo);   
  48.   
  49.      }   
  50.   
  51.  }  
public class ThreadTest3 extends Thread {

 

     private int threadNo;

    private String lock;



     public ThreadTest3(int threadNo) {

         this.threadNo = threadNo;

     }



     public static void main(String[] args) throws Exception {

         //String lock = new String("lock");

         for (int i = 1; i < 20; i++) {

             new ThreadTest3(i).start();

             Thread.sleep(1);

        }

     }

     public static synchronized void abc(int threadNo) {

         for (int i = 1; i < 10000; i++) {
           
                System.out.println("No." + threadNo + ":" + i);
                
         }

     }

 

     public void run() {

         abc(threadNo);

     }

 }

 细心的读者发现了：这段代码没有使用main方法中创建的String对象作为这10个线程的线程锁。而是通过在run方法中调用本线程中一个静态的同步方法abc而实现了线程的同步。我想看到这里，你们应该很困惑：这里synchronized静态方法是用什么来做对象锁的呢？

我们知道，对于同步静态方法，对象锁就是该静态放发所在的类的Class实例，由于在JVM中，所有被加载的类都有唯一的类对象，具体到本例，就是唯一的 ThreadTest3.class对象。不管我们创建了该类的多少实例，但是它的类实例仍然是一个！

这样我们就知道了：
转载注明出处：http://x-spirit.iteye.com/、http://www.blogjava.net/zhangwei217245/
1、对于同步的方法或者代码块来说，必须获得对象锁才能够进入同步方法或者代码块进行操作；
转载注明出处：http://x-spirit.iteye.com/、http: //www.blogjava.net/zhangwei217245/
2、如果采用method级别的同步，则对象锁即为method所在的对象，如果是静态方法，对象锁即指method所在的
Class对象(唯一)；
转载注明出处：http://x-spirit.iteye.com/、http: //www.blogjava.net/zhangwei217245/
3、对于代码块，对象锁即指synchronized(abc)中的abc；
转载注明出处：http://x-spirit.iteye.com/、http: //www.blogjava.net/zhangwei217245/
4、因为第一种情况，对象锁即为每一个线程对象，因此有多个，所以同步失效，第二种共用同一个对象锁lock，因此同步生效，第三个因为是
static因此对象锁为ThreadTest3的class 对象，因此同步生效。转载注明出处：http://x-spirit.iteye.com/、http: //www.blogjava.net/zhangwei217245/
转载注明出处：http://x-spirit.iteye.com/、http: //www.blogjava.net/zhangwei217245/
如上述正确，则同步有两种方式，同步块和同步方法（为什么没有wait和notify？这个我会在补充章节中做出阐述）

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

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

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

所以说，在Java多线程编程中，最常见的synchronized关键字实际上是依靠对象锁的机制来实现线程同步的。
我们似乎可以听到synchronized在向我们说：“给我一把 锁，我能创造一个规矩”。

下一篇中，我们将看到JDK 5提供的新的同步机制，也就是大名鼎鼎的Doug Lee提供的Java Concurrency框架。

分享到：
| Java多线程同步问题的探究（一、线程的先来 ...
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    Java多线程同步问题的探究.pdf

    总之，Java多线程同步问题的探究是一个复杂而深入的话题，涉及了synchronized关键字、JDK 5的高级锁机制、ThreadLocal的线程局部存储以及JVM的线程管理等多个方面。了解这些知识点，对于深入理解Java多线程编程和...

    Java多线程同步.pdf

    "Java多线程同步.pdf" Java多线程同步是指在Java语言中，如何使用synchronized关键字和其他同步机制来确保多线程程序的正确执行。在Java语言中，synchronized关键字用于对方法或者代码块进行同步，但是仅仅使用...

    Java多线程同步机制研究分析.pdf

    Java多线程同步机制是Java编程语言中的一种机制，它允许多个线程同时执行，提高了系统资源的利用率和安全性。但是，多线程中最重要的问题是线程的同步和共享资源的访问保护。本文通过对Java多线程同步机制的研究和...

    java多线程同步例子

    java多线程同步互斥访问实例，对于初学者或是温故而知新的同道中人都是一个很好的学习资料

    Java多线程同步具体实例讲解 .doc

    Java多线程同步是编程中一个非常重要的概念，特别是在并发编程和高并发系统设计中起到关键作用。在Java中，为了保证线程安全，避免数据竞争和不一致的状态，我们通常会使用同步机制来控制对共享资源的访问。本文将...

    Java多线程知识点总结

    Java多线程是Java编程语言中一个非常重要的概念，它允许开发者在一个程序中创建多个执行线程并行运行，以提高程序的执行效率和响应速度。在Java中，线程的生命周期包含五个基本状态，分别是新建状态（New）、就绪...

    JAVA实现线程间同步与互斥生产者消费者问题

    本项目通过一个生产者消费者问题的实例，展示了如何在Java中实现线程间的同步与互斥。 生产者消费者问题是经典的并发问题之一，它涉及到两个类型的线程：生产者和消费者。生产者负责生成数据（产品），而消费者则...

    Java多线程同步机制的应用分析.pdf

    "Java多线程同步机制的应用分析" Java多线程同步机制的应用分析是指在Java语言中，如何使用同步机制来保护临界区，以避免多线程之间的冲突和错误。该机制通过管程机制和同步语法来保护临界区，使得多线程可以安全...

    java多线程之并发锁

    在多线程编程中，线程间的同步是非常重要的，因为不同的线程可能会同时访问同一个共享资源，导致数据不一致和其他一些问题。这时，锁机制就发挥了重要的作用。 在 Java 中，有两种主要的锁机制：synchronized ...

    Java多线程同步具体实例.doc

    Java多线程同步是编程中一个非常重要的概念，特别是在并发编程中，用于解决多个线程访问共享资源时可能引发的数据不一致问题。本实例通过一个简单的火车票售票系统来演示同步机制的应用。 在这个实例中，我们创建了...

    java多线程经典案例

    本案例将深入探讨Java多线程中的关键知识点，包括线程同步、线程通信和线程阻塞。 线程同步是为了防止多个线程同时访问共享资源，导致数据不一致。Java提供了多种同步机制，如synchronized关键字、Lock接口...

    java 多线程同步方法的实例

    在Java编程语言中，多线程同步是一种控制多个线程并发执行的重要机制，它确保了共享资源的安全访问，防止数据不一致性和竞态条件的发生。本文将深入探讨Java中的多线程同步方法，并通过实例来阐述其工作原理。 首先...

    java多线程Demo

    Java多线程是Java编程中的一个重要概念，它允许程序同时执行多个任务，提高了程序的效率和响应速度。在Java中，实现多线程有两种主要方式：继承Thread类和实现Runnable接口。 1. 继承Thread类： 当我们创建一个新...

    java 多线程 同步详解

    `synchronized`是Java中的一个关键字，用于控制多线程对共享资源的访问。它提供了一种互斥访问的机制，确保在任意时刻只有一个线程可以执行特定的代码块或方法。 3. **同步方法** 当在方法前加上`synchronized`...

    java多线程同步分析

    Java多线程同步是编程中一个重要的概念，特别是在并发编程中，它用于管理多个线程对共享资源的访问，防止数据的不一致性。线程同步是解决多线程并发问题的关键，确保线程按照一定的顺序执行，避免竞态条件。 线程在...

    JAVA单线程多线程

    在Java编程环境中，单线程指的是程序执行过程中只有一个线程在运行。这意味着任何时刻只能执行一个任务，上一个任务完成后才会进行下一个任务。单线程模型简化了程序设计，降低了程序复杂度，使得开发者可以更专注于...

    Java多线程同步机制在售票系统的实现

    本文旨在通过分析一个具体的案例——长途汽车售票系统的多线程同步机制实现，来探讨如何利用Java的多线程技术解决实际问题。 #### 二、多线程的基本概念 ##### 2.1 线程与进程的主要区别 1. **划分粒度**：线程的...

    Java多线程同步问题分析.pdf

    Java多线程同步问题分析主要关注的是在并发环境中如何有效地管理共享资源，避免出现数据竞争和不一致性。在Java编程中，多线程是提升程序性能的重要手段，尤其是在服务器端应用和服务中。然而，当多个线程同时访问并...

    java 多线程并发实例

    - 生产者-消费者模型：这是一个经典的多线程设计模式，用于解决资源的生产与消费问题。生产者线程负责生成数据，放入缓冲区；消费者线程则负责取出数据进行处理。Java的BlockingQueue接口（如ArrayBlockingQueue）...

Magicbox
Global site tag (gtag.js) - Google Analytics