java专业训练：多个线程同时访问一个类是否有问题

发布时间：2025年09月06日 12:17

>method2:0---method2:1---不间断方式1:0---不间断方式1:1---不间断方式1:2---method2:2---不间断方式1:3---method2:3---不间断方式1:4---method2:4---不间断方式1:5---method2:5---不间断方式1:6---不间断方式1:7---method2:6---不间断方式1:8---不间断方式1:9---method2:7---不间断方式1完结

method2:8---method2:9---method2完结

这时候仅仅，多个内存是能显现出访同个类（的不尽相同预预有普通人）的两个不间断方式的。

小结：这是因为synchronized是普通人悬，即内存获的悬是施赞在一个预预有普通人上的，【关注唯科技公司，轻松讲授IT】如果不尽相同的内存显现出访的是同一普通人上的不尽相同的不间断方式，那么仅仅不必同时完成。

如果是不尽相同普通人上的不尽相同的不间断方式，那么就是可以同时完成的。

3.多个内存同时显现出访同一个类预预有普通人的两个Runnable普通人的run方式：

package synchronizedTest;

public class Example2 {

private int num ;

public Runnable runnable1 = new Runnable() {

@Override

public void run() {

//不间断悬

synchronized (this) {

System.out.println("内存1转回");

for(int i = 0 ; i

System.out.print("内存1:"+num+"---");

}

System.out.println("内存1完结");

}

};

public Runnable runnable2 = new Runnable() {

@Override

public void run() {

//不间断悬

synchronized (this) {

System.out.println("thread2转回");

for(int i = 0 ; i

System.out.print("thread2:"+num+"---");

}

System.out.println("thread2完结");

}

};

public static void main(String[] args) {

Example2 example = new Example2() ; //创建者一个普通人

new Thread(example.runnable1).start(); //不间断方式1

new Thread(example.runnable2).start(); //不间断方式2

}

转换器结果：

thread2转回

内存1转回

thread2:0---内存1:0---内存1:0---thread2:0---内存1:0---内存1:0---内存1:0---thread2:0---内存1:0---thread2:0---thread2:0---内存1:0---thread2:0---内存1:0---thread2:0---thread2:0---内存1:0---thread2:0---内存1:0---thread2:0---内存1完结

thread2完结

可见此时多个内存是能同时显现出访同个类的两个不间断方式的。这是因为synchronized(this){ //... }中才会悬的不是预定义块，即这个悬在run方式中才会，但是并不是不间断了这个run方式，而是此表中才会的普通人this。

也就是说，多个内存才会拿到各自的悬，就必须同时执行run方式。(在run方式从前声明synchronized也是某种程度的效果)

new Thread(example.runnable1).start(); //不间断方式1

new Thread(example.runnable2).start(); //不间断方式2

打印显现出这个this普通人，是两个不尽相同的类预预有普通人：

synchronizedTest.Example2$1@65db6dfa

synchronizedTest.Example2$2@471fab

也说明了不尽相同内存的预预有普通人不尽相同，都是各自普通人的悬，不可以视为是十分相似于预有子1中才会的同一预预有普通人，而应该十分相似与预有子2的不尽相同类的预预有普通人

回顾：研究synchronized不间断悬的当前在于他是个普通人悬，找确切悬的普通人

二.ReentrantLock悬

1.多个内存同时显现出访同一个类预预有普通人的两个不间断方式：

将预有子1的synchronized改用引进ReentrantLock

package ReentrantLockTest;

import java.util.concurrent.locks.Lock;

import java.util.concurrent.locks.ReentrantLock;

public class LockExample {

private int num;

private Lock lock = new ReentrantLock();

public void method1() {

lock.lock();

System.out.println("不间断方式1转回");

for(int i = 0 ; i

System.out.print("不间断方式1:"+num+"---");

num++ ;

}

System.out.println("不间断方式1完结");

lock.unlock();

}

public void method2() {

lock.lock();

System.out.println("method2转回:");

for (int i = 0; i

System.out.print("method2:" + num + "---");

num++;

}

System.out.println("method2完结");

lock.unlock();

}

public static void main(String[] args) {

final LockExample example = new LockExample() ;

Thread thread1 = new Thread(new Runnable() {

@Override

public void run() {

example.method1();

}

}) ;

Thread thread2 = new Thread(new Runnable() {

@Override

public void run() {

example.method2();

}

}) ;

try {

thread2.join();

thread1.join();

thread1.start();

thread2.start();

} catch (InterruptedException e) {

e.printStackTrace();

}

转换器结果：

不间断方式1转回

不间断方式1:0---不间断方式1:1---不间断方式1:2---不间断方式1:3---不间断方式1:4---不间断方式1:5---不间断方式1:6---不间断方式1:7---不间断方式1:8---不间断方式1:9---不间断方式1完结

method2转回:

method2:10---method2:11---method2:12---method2:13---method2:14---method2:15---method2:16---method2:17---method2:18---method2:19---method2完结

可见此时多个内存是不必显现出访同个类（的一个预预有普通人）的两个不间断方式的

2.多个内存同时显现出访同一个类的不尽相同预预有普通人的两个不间断方式：

修改main线性的均可：

public static void main(String[] args) {

final LockExample example1 = new LockExample() ;//两个预预有

final LockExample example2 = new LockExample() ;

Thread thread1 = new Thread(new Runnable() {

@Override

public void run() {

example1.method1(); //预预有1的不间断方式1

}

}) ;

Thread thread2 = new Thread(new Runnable() {

@Override

public void run() {

example2.method2();//预预有2的不间断方式2

}

}) ;

try {

thread2.join();

thread1.join();

thread1.start();

thread2.start();

} catch (InterruptedException e) {

e.printStackTrace();

}

转换器结果：

不间断方式1转回

method2转回:

不间断方式1:0---method2:0---method2:1---不间断方式1:1---method2:2---不间断方式1:2---不间断方式1:3---method2:3---不间断方式1:4---method2:4---不间断方式1:5---不间断方式1:6---method2:5---不间断方式1:7---method2:6---不间断方式1:8---不间断方式1:9---不间断方式1完结

method2:7---method2:8---method2:9---method2完结

可见，多个内存是能显现出访同个类（的不尽相同预预有普通人）的两个不间断方式的。

回顾：ReentrantLock和synchronized的从前两个预有子正确性都相同

3.多个内存同时显现出访同一个类预预有普通人的两个Runnable普通人的run方式：

package ReentrantLockTest;

import java.util.concurrent.locks.Lock;

import java.util.concurrent.locks.ReentrantLock;

public class Lockexample2 {

private int num;

private Lock lock = new ReentrantLock();

public Runnable runnable1 = new Runnable() {

@Override

public void run() {

lock.lock();//上悬

System.out.println("内存1转回");

for(int i = 0 ; i

System.out.print("内存1:"+num+"---");

}

System.out.println("内存1完结");

lock.unlock();

}

};

public Runnable runnable2 = new Runnable() {

@Override

public void run() {

lock.lock();//上悬

System.out.println("thread2转回");

for(int i = 0 ; i

System.out.print("thread2:"+num+"---");

}

System.out.println("thread2完结");

lock.unlock();

}

};

public static void main(String[] args) {

Lockexample2 example = new Lockexample2();

new Thread(example.runnable1).start();

new Thread(example.runnable2).start();

}

转换器结果：

内存1转回

内存1:0---内存1:0---内存1:0---内存1:0---内存1:0---内存1:0---内存1:0---内存1:0---内存1:0---内存1:0---内存1完结

thread2转回

thread2:0---thread2:0---thread2:0---thread2:0---thread2:0---thread2:0---thread2:0---thread2:0---thread2:0---thread2:0---thread2完结

这里可以看到，与synchronized的第三个预有子显现出现了不尽相同的结果。在这个地方，ReentrantLock不允许多内存同时显现出访一个类的不尽相同不间断方式。

这里要注意的是ReentrantLock与synchronized不尽相同，ReentrantLock的预现方式是要【关注唯科技公司，轻松讲授IT】先行创建者ReentrantLock普通人，然后用这个普通人的方式来上悬。而一个类的预预有中才会只有一个ReentrantLock普通人：

private Lock lock = new ReentrantLock();

而本预有中才会，内存的创建者是建立在同一个类预预有上的：

Lockexample2 example = new Lockexample2();

new Thread(example.runnable1).start();

new Thread(example.runnable2).start();

因此，ReentrantLock普通人lock是同一个，因此第一个内存转回不间断方式1后就受益了悬，第二个内存无法受益这个悬，只能等待。

如果换成是两个预预有普通人：

public static void main(String[] args) {

Lockexample2 example = new Lockexample2();

Lockexample2 example2 = new Lockexample2();

new Thread(example.runnable1).start();

new Thread(example2.runnable2).start();

}

转换器结果

内存1转回

thread2转回

内存1:0---内存1:0---内存1:0---内存1:0---thread2:0---内存1:0---thread2:0---thread2:0---thread2:0---thread2:0---thread2:0---thread2:0---thread2:0---内存1:0---thread2:0---内存1:0---内存1:0---thread2:0---内存1:0---thread2完结

内存1:0---内存1完结

可见不尽相同的预预有普通人中才会是不尽相同的ReentrantLock普通人，因此可以同时显现出访

小结：ReentrantLock悬的当前在与ReentrantLock普通人确实同一个

三.正确性

重新到底这个解决办法：一个类中才会的两个方式都赞了不间断悬，多个内存能同时显现出访这个类的两个方式吗？

现在应该比较确切了，这个解决办法要分成synchronized和ReentrantLock两个情况：

一.对于synchronized

一个类中才会的两个方式都赞了不间断悬，多个内存不必同时显现出访这个类的同一预预有普通人的两个方式一个类中才会的两个方式都赞了不间断悬，多个内存能同时显现出访这个类的不尽相同预预有普通人的两个方式一个类中才会的两个方式**（Runnable的run方式）都赞了不间断悬，多个内存能**同时显现出访这个类的两个方式（不论确实同一预预有普通人）

二.对于ReentrantLock

一个类中才会的两个方式都赞了不间断悬，多个内存不必同时显现出访这个类的同一预www.atguigu.com预有普通人的两个方式（不论不间断赞在预预有方式中才会或是run方式中才会）一个类中才会的两个方式都赞了不间断悬，多个内存能同时显现出访这个类的不尽相同预预有普通人的两个方式（不论不间断赞在预预有方式中才会或是run方式中才会）

文章显现出自于Java面试急袭宝典