Java------synchronized理解
synchronized理解
synchronized是一个排它锁，既能够锁方法，又能够锁代码块。
用于实现线程同步，多个线程依次获取资源。
synchronized 在方法上，且非静态方法
此时锁的是方法调用者。
示例：两个线程
结果：先输入B，在输出A
public class Test {
public static void main(String[] args) {
Data data = new Data();
new Thread(()->{
try {
data.fun01();
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();
new Thread(()->{
try {
data.fun02();
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();
}
}
class Data{
public void fun01() throws InterruptedException {
TimeUnit.SECONDS.sleep(3);
System.out.println("A----1");
}
public void fun02() throws InterruptedException {
TimeUnit.SECONDS.sleep(1);
System.out.println("B----2");
}
}
在方法上加上synchronized ，就会出现：
3秒后输出A
再过1秒，输出B的情况。
package com.springdemo.demo;
import java.util.concurrent.TimeUnit;
public class Test {
public static void main(String[] args) {
Data data = new Data();
new Thread(()->{
try {
data.fun01();
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();
new Thread(()->{
try {
data.fun02();
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();
}
}
class Data{
public synchronized void fun01() throws InterruptedException {
TimeUnit.SECONDS.sleep(3);
System.out.println("A----1");
}
public synchronized void fun02() throws InterruptedException {
TimeUnit.SECONDS.sleep(1);
System.out.println("B----2");
}
}
如果将fun02()上的synchronized 去掉就会出现，先输出B再输出A的情况。
同样的如果是两个对象，
Data data = new Data();
Data data2 = new Data();
这两个对象分别调用fun01，和fun02，也不会出现资源争夺的情况，
结果就是先输出B，再输出A。
synchronized关键字在静态方法上
class Data{
public synchronized static void fun01() throws InterruptedException {
TimeUnit.SECONDS.sleep(3);
System.out.println("A----1");
}
public synchronized static void fun02() throws InterruptedException {
System.out.println("B----2");
}
}
结果表现：则是3秒后，先输出A，再输出B。依然对资源进行线程的排队获取的处理。
synchronized关键字修饰代码块
public static void main(String[] args) {
Data2 data2 = new Data2();
for (int i = 0;i<5;i++){
new Thread(()->{
try {
data2.fun3();
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();
}
}
class Data2{
public void fun3() throws InterruptedException {
System.out.println("3----start");
TimeUnit.SECONDS.sleep(3);
System.out.println("3----end");
}
}
此时结果是：输出5个start，过3秒后，再输出5个end。
加上synchronized 锁代码块，this锁的对象
public void fun3() throws InterruptedException {
synchronized (this){
System.out.println("3----start");
TimeUnit.SECONDS.sleep(3);
System.out.println("3----end");
}
}
结果：此时会排队，一个start，一个end，循环5次。
此时的this，代表当前的实例化对象。此时5个线程，公用一个data2 对象。
将data2放到循环中
public static void main(String[] args) {
for (int i = 0;i<5;i++){
new Thread(()->{
try {
Data2 data2 = new Data2();
data2.fun3();
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();
}
}
此时，又是同时开始，同时结束，输出5次start，再输出5次end。
如果synchronized (Data2.class)，此时锁的是Data2这个类。
public void fun3() throws InterruptedException {
synchronized (Data2.class){
System.out.println("3----start");
TimeUnit.SECONDS.sleep(3);
System.out.println("3----end");
}
}
此时尽管循环创建新的data2对象，也依然会排队。start、end依次循环输出。
如果synchronized (一个变量)
public void fun3() throws InterruptedException {
String num = "1";
synchronized (num){
System.out.println("3----start");
TimeUnit.SECONDS.sleep(3);
System.out.println("3----end");
}
}
结果：此时需要排队…
但是，如果这个num是参数传进来的呢？是否排队输出？
public static void main(String[] args) {
for (int i = 0;i<5;i++){
new Thread(()->{
try {
Data2 data2 = new Data2();
String s="A";
data2.fun3(s);
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();
}
}
class Data2{
public void fun3(String num) throws InterruptedException {
synchronized (num){
System.out.println("3----start");
TimeUnit.SECONDS.sleep(3);
System.out.println("3----end");
}
}
}
此时是需要排队输出，因为此时的String s=“A”;是常量池中拿出，只有一个。
如果传入的变量不是同一个呢？输出结果是什么样？
public static void main(String[] args) {
for (int i = 0;i<5;i++){
new Thread(()->{
try {
UUID uuid = UUID.randomUUID();
Data2 data2 = new Data2();
String s="asdasdasdasdasd"+uuid;
data2.fun3(s);
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();
}
}
答案：此时不需要排队，会先输出5个start，再输出5个end。因为此时每个a都是单独的对象。