文章目录
- 1、修饰方法
- 1.1、静态方法，锁定的是类
- 1.2、非静态方法，锁定的是方法的调用者（对象）
- 2、修饰代码块，锁定的是传入的对象
- 2.1、没有锁之前：
- 2.2、有锁后：
实现线程同步，让多个线程排队依次获取某个资源，保证数据不会出错。
synchronized是Java中的关键字，是一种同步锁。它修饰的对象有以下几种：
- 修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象；
- 修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象；
- 修改一个静态的方法，其作用的范围是整个静态方法，作用的对象是这个类的所有对象；
- 修改一个类，其作用的范围是synchronized后面括号括起来的部分，作用主的对象是这个类的所有对象。
1、修饰方法
1.1、静态方法，锁定的是类
package com.htl.Synchronized;
import java.util.concurrent.TimeUnit;
public class Test {
public static void main(String[] args) {
Fun fun1 = new Fun();
Fun fun2 = new Fun();
//线程A
new Thread(new Runnable() {
@Override
public void run() {
fun1.f1();
}
},"A线程").start();
//休眠1秒
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
//线程B
new Thread(new Runnable() {
@Override
public void run() {
fun2.f2();
}
},"线程B").start();
}
}
class Fun{
public synchronized static void f1(){
try {
TimeUnit.SECONDS.sleep(3);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("f1...");
}
public synchronized static void f2() {
System.out.println("f2...");
}
}
过3秒钟过后，f1、f2同时输出。
1.2、非静态方法，锁定的是方法的调用者（对象）
package com.htl.Synchronized;
import java.util.concurrent.TimeUnit;
public class Test {
public static void main(String[] args) {
Fun fun = new Fun();
//线程A
new Thread(new Runnable() {
@Override
public void run() {
fun.f1();
}
},"A线程").start();
//休眠1秒
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
//线程B
new Thread(new Runnable() {
@Override
public void run() {
fun.f2();
}
},"线程B").start();
}
}
class Fun{
public synchronized void f1(){
try {
TimeUnit.SECONDS.sleep(3);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("f1...");
}
public synchronized void f2() {
System.out.println("f2...");
}
}
过3秒钟过后，f1、f2同时输出。
2、修饰代码块，锁定的是传入的对象
2.1、没有锁之前：
package com.htl.Synchronized;
import java.util.concurrent.TimeUnit;
public class Test2 {
public static void main(String[] args) {
Fun2 fun2 = new Fun2();
for (int i = 0; i < 5; i++) {
new Thread(new Runnable() {
@Override
public void run() {
fun2.f1();
}
}).start();
}
}
}
class Fun2{
public void f1(){
System.out.println("start...");
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("end...");
}
}
先输出5个start… 过1秒再输出5个end…
2.2、有锁后：
package com.htl.Synchronized;
import java.util.concurrent.TimeUnit;
public class Test2 {
public static void main(String[] args) {
Fun2 fun2 = new Fun2();
for (int i = 0; i < 5; i++) {
new Thread(new Runnable() {
@Override
public void run() {
fun2.f1();
}
}).start();
}
}
}
class Fun2{
public void f1(){
synchronized (this){
System.out.println("start...");
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("end...");
}
}
}
package com.htl.Synchronized;
import java.util.concurrent.TimeUnit;
public class Test2 {
public static void main(String[] args) {
Fun2 fun2 = new Fun2();
//开启5个线程
for (int i = 0; i < 5; i++) {
new Thread(new Runnable() {
@Override
public void run() {
Integer num = 1;
fun2.f1(num);
}
}).start();
}
}
}
class Fun2{
public void f1(Integer num){
synchronized (num){
System.out.println("start...");
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("end...");
}
}
}
