Synchronzied关键字的作用是线程同步，它可以用来修饰对象中的方法，将对象加锁。
1、Synchronzied的几个分类
1）非静态方法的同步
//每个对象各持有一把锁
//懒，就写一起了
public class MainTest {
//测试方法
public static void main(String[] args) throws Exception {
MainTest mainTest = new MainTest();
//mainTest.synchronizedTest1();
mainTest.synchronizedTest2();
}
public void synchronizedTest2() {
//2、2个对象 每个对象各持有一把锁
Test test = new Test();
Test test2 = new Test();
MyRunale myRunale2 = new MyRunale(test2, 2);
Thread thread2 = new Thread(myRunale2);
thread2.start();
test.test1();
//会打印2条记录
}
public void synchronizedTest1() {
//1、同一个对象 只持有一把锁
//只持有一把锁
Test test = new Test();
MyRunale myRunale2 = new MyRunale(test, 2);
Thread thread2 = new Thread(myRunale2);
thread2.start();
test.test1();
//只会打印1条记录
}
public class MyRunale implements Runnable {
private Test test;
private int type;
public MyRunale(Test test, int type) {
this.test = test;
this.type = type;
}
@Override
public void run() {
if (type == 1) {
test.test1();
} else {
test.test2();
}
}
}
public class Test {
public synchronized void test1() {
System.out.println("我是test1");
try {
Thread.sleep(10000000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public synchronized void test2() {
System.out.println("我是test2");
try {
Thread.sleep(10000000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
2）静态方法的同步
//所有静态方法的锁也只有一个
//静态方法的锁和 非静态方法的锁是不一样的
//懒，就写一起了
public class MainTest {
//测试方法
public static void main(String[] args) throws Exception {
MainTest mainTest = new MainTest();
//mainTest.synchronizedTest1();
mainTest.synchronizedTest2();
}
public void synchronizedTest2() {
//静态方法的锁和 非静态方法的锁是不一样的
System.out.println("-------------synchronizedTest2开始-------------");
Test test = new Test();
MyRunale myRunale2 = new MyRunale(test, 1);
Thread thread2 = new Thread(myRunale2);
thread2.start();
test.test0();
System.out.println("-------------synchronizedTest2结束-------------");
//会打印2条记录
}
public void synchronizedTest1() {
//所有静态方法的锁也只有一个
System.out.println("-------------synchronizedTest1开始-------------");
Test test = new Test();
Test test2 = new Test();
MyRunale myRunale2 = new MyRunale(test2, 0);
Thread thread2 = new Thread(myRunale2);
thread2.start();
test.test0();
System.out.println("-------------synchronizedTest1结束-------------");
//会打印1条记录
}
public class MyRunale implements Runnable {
private Test test;
private int type;
public MyRunale(Test test, int type) {
this.test = test;
this.type = type;
}
@Override
public void run() {
if (type == 1) {
test.test1();
} else if (type == 2) {
test.test2();
} else if (type == 0) {
test.test00();
}
}
}
}
public class Test {
public static synchronized void test00() {
System.out.println("我是test00");
try {
Thread.sleep(10000000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public static synchronized void test0() {
System.out.println("我是test0");
try {
Thread.sleep(10000000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public synchronized void test1() {
System.out.println("我是test1");
try {
Thread.sleep(10000000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public synchronized void test2() {
System.out.println("我是test2");
try {
Thread.sleep(10000000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
3）类的同步
//同步块中的锁只有一个，即使是多个对象也只有一个
public void method() {
synchronized(SomeClass.class) {
}
}
//懒，就写一起了
public class MainTest {
//测试方法
public static void main(String[] args) throws Exception {
MainTest mainTest = new MainTest();
mainTest.synchronizedTest1();
}
public void synchronizedTest1() {
Test test2 = new Test();
MyRunale myRunale2 = new MyRunale(test2, 2);
Thread thread2 = new Thread(myRunale2);
thread2.start();
Test test = new Test();
test.test1();
// -----test1开始-----
// -----test1执行中-----
// -----test2开始-----
}
public class MyRunale implements Runnable {
private Test test;
private int type;
public MyRunale(Test test, int type) {
this.test = test;
this.type = type;
}
@Override
public void run() {
if (type == 1) {
test.test1();
} else {
test.test2();
}
}
}
}
public class Test {
public void test1() {
System.out.println("-----test1开始-----");
synchronized(Test.class){
try {
System.out.println("-----test1执行中-----");
Thread.sleep(10000000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("-----test1结束-----");
}
public void test2() {
System.out.println("-----test2开始-----");
synchronized(Test.class){
try {
System.out.println("-----test2执行中-----");
Thread.sleep(10000000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("-----test2结束-----");
}
}
4）公共对象的同步
//没有static则每个test对象对于lock对象都有不同的锁
private static Object lock=new Object();
public void method() {
synchronized(lock) {
}
}
//懒，就写一起了
public class MainTest {
//测试方法
public static void main(String[] args) throws Exception {
MainTest mainTest = new MainTest();
mainTest.synchronizedTest1();
}
public void synchronizedTest1() {
Test test2 = new Test();
MyRunale myRunale2 = new MyRunale(test2, 2);
Thread thread2 = new Thread(myRunale2);
thread2.start();
Test test = new Test();
test.test1();
// -----test1开始-----
// -----test1执行中-----
// -----test2开始-----
}
public class MyRunale implements Runnable {
private Test test;
private int type;
public MyRunale(Test test, int type) {
this.test = test;
this.type = type;
}
@Override
public void run() {
if (type == 1) {
test.test1();
} else {
test.test2();
}
}
}
}
public class Test {
//没有static则每个test对象对于lock对象都有不同的锁
private static Object lock = new Object();
public void test1() {
System.out.println("-----test1开始-----");
synchronized (lock) {
try {
System.out.println("-----test1执行中-----");
Thread.sleep(10000000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("-----test1结束-----");
}
public void test2() {
System.out.println("-----test2开始-----");
synchronized (lock) {
try {
System.out.println("-----test2执行中-----");
Thread.sleep(10000000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("-----test2结束-----");
}
}