java多线程(二) 多线程的同步_我有一个线程在执行同步代码另一个线程会执行同步代码下面的输出语句吗多线程-优快云博客

本文详细介绍了Java中同步的概念、线程同步的方法（包括同步方法、同步代码块及使用Lock对象）以及如何实现线程同步。通过实例演示了不同同步方式的应用，并解释了同步方法、代码块和静态方法在实现线程同步时的不同对象锁机制。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

一、为什么使用同步

java允许多线程并发控制，当多个线程同时操作一个可共享的资源变量时（如数据的增删改查），将会导致数据不准确，相互之间产生冲突，因此加入同步锁以避免在该线程没有完成操作之前，被其他线程的调用，从而保证了该变量的唯一性和准确性。

二、线程同步的方法

关于线程的同步，一般有以下解决方法：
1.同步方法

即有synchronized关键字修饰的方法。由于java的每个对象都有一个内置锁，当用此关键字修饰方法时，内置锁会保护整个方法。在调用该方法前，需要获得内置锁，否则就处于阻塞状态。

代码如： public synchronized void save(){}

注： synchronized关键字也可以修饰静态方法，此时如果调用该静态方法，将会锁住整个类

2.同步代码块

即有synchronized关键字修饰的语句块。被该关键字修饰的语句块会自动被加上内置锁，从而实现同步

代码如： synchronized(object){ }

3. 使用JDK 5中提供的java.util.concurrent.lock包中的Lock对象。

三、程序实例

先来看一个例子

package com.test.Thread;

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 < 100; i++) {   
            System.out.println("No." + threadNo + ":" + i);   
        }   
     }   
 }

这个程序其实就是让10个线程在控制台上数数，从1数到99。理想情况下，我们希望看到一个线程数完，然后才是另一个线程开始数数。但是这个程序的执行过程告诉我们，这些线程还是乱糟糟的在那里抢着报数，丝毫没有任何规矩可言。
但是细心的读者注意到：run方法还是加了一个synchronized关键字的，按道理说，这些线程应该可以一个接一个的执行这个run方法才对啊。但是对于一个成员方法加synchronized关键字，这实际上是以这个成员方法所在的对象本身作为对象锁。在本例中，就是以ThreadTest类的一个具体对象，也就是该线程自身作为对象锁的。一共十个线程，每个线程持有自己线程对象的那个对象锁。这必然不能产生同步的效果。换句话说，如果要对这些线程进行同步，那么这些线程所持有的对象锁应当是共享且唯一的！

来看下面的例子：

package com.test.Thread;

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 < 100; i++) {   
    			System.out.println("No." + threadNo + ":" + i);   
    		}      
    	}     
   }
}

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

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

再来看下面的例子：

package com.test.Thread;

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 {
        for (int i = 1; i < 10; i++) {   
            new ThreadTest3(i).start();   
            Thread.sleep(1);   
        }   
    }   
   
    public static synchronized void abc(int threadNo) {
        for (int i = 1; i < 100; i++) {   
        	System.out.println("No." + threadNo + ":" + i);           
        }   
    }   
   
    public void run() {   
        abc(threadNo);   
    }   
}

细心的读者发现了：这段代码没有使用main方法中创建的String对象作为这10个线程的线程锁。而是通过在run方法中调用本线程中一个静态的同步方法abc而实现了线程的同步。我想看到这里，你们应该很困惑：这里synchronized静态方法是用什么来做对象锁的呢？
我们知道，对于同步静态方法，对象锁就是该静态方法所在的类的Class实例，由于在JVM中，所有被加载的类都有唯一的类对象，具体到本例，就是唯一的ThreadTest3.class对象。不管我们创建了该类的多少实例，但是它的类实例仍然是一个！

四、总结

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

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

如果是同步方法，则分静态和非静态两种 。静态方法则一定会同步，非静态方法需在单例模式才生效，推荐用静态方法(不用担心是否单例)。
所以说，在Java多线程编程中，最常见的synchronized关键字实际上是依靠对象锁的机制来实现线程同步的。
我们似乎可以听到synchronized在向我们说：“给我一把锁，我能创造一个规矩”。

一段synchronized的代码被一个线程执行之前，他要先拿到执行这段代码的权限，在 java里边就是拿到某个同步对象的锁（一个对象只有一把锁）；如果这个时候同步对象的锁被其他线程拿走了，他（这个线程）就只能等了（线程阻塞在锁池等待队列中）。取到锁后，他就开始执行同步代码(被synchronized修饰的代码）；线程执行完同步代码后马上就把锁还给同步对象，其他在锁池中等待的某个线程就可以拿到锁执行同步代码了。这样就保证了同步代码在统一时刻只有一个线程在执行。