用关键字synchronized声明方法在某些情况下是有弊端的，比如A线程调用同步方法之行一个长时间的任务，那么B线程必须等待比较长的时间，在这样的情况下可以使用synchronized同步语句快来解决。
一、用同步代码块解决同步方法的弊端
Task类
1 package com.weishiyao.learn.day4.testSynchorized.ep2;
2
3 public class Task {
4
5 private String getData1;
6 private String getData2;
7
8 public void doLongTimeTask() {
9 try {
10 System.out.println("begin task");
11 Thread.sleep(3000);
12
13 String privateGetData1 = "长时间处理任务后从远程返回的值1 threadName="
14 + Thread.currentThread().getName();
15 String privateGetData2 = "长时间处理任务后从远程返回的值2 threadName="
16 + Thread.currentThread().getName();
17
18 synchronized (this) {
19 getData1 = privateGetData1;
20 getData2 = privateGetData2;
21 }
22
23 System.out.println(getData1);
24 System.out.println(getData2);
25 System.out.println("end task");
26 } catch (InterruptedException e) {
27 e.printStackTrace();
28 }
29 }
30 }
常量工具类
1 package com.weishiyao.learn.day4.testSynchorized.ep2;
2
3 public class CommonUtils {
4
5 public static long beginTime1;
6 public static long endTime1;
7
8 public static long beginTime2;
9 public static long endTime2;
10 }
线程类——2个
1 package com.weishiyao.learn.day4.testSynchorized.ep2;
2
3 public class MyThread1 extends Thread {
4
5 private Task task;
6
7 public MyThread1(Task task) {
8 super();
9 this.task = task;
10 }
11
12 @Override
13 public void run() {
14 super.run();
15 CommonUtils.beginTime1 = System.currentTimeMillis();
16 task.doLongTimeTask();
17 CommonUtils.endTime1 = System.currentTimeMillis();
18 }
19
20 }
1 package com.weishiyao.learn.day4.testSynchorized.ep2;
2
3 public class MyThread2 extends Thread {
4
5 private Task task;
6
7 public MyThread2(Task task) {
8 super();
9 this.task = task;
10 }
11
12 @Override
13 public void run() {
14 super.run();
15 CommonUtils.beginTime2 = System.currentTimeMillis();
16 task.doLongTimeTask();
17 CommonUtils.endTime2 = System.currentTimeMillis();
18 }
19
20 }
运行类
1 package com.weishiyao.learn.day4.testSynchorized.ep2;
2
3 public class Run {
4
5 public static void main(String[] args) {
6 Task task = new Task();
7
8 MyThread1 thread1 = new MyThread1(task);
9 thread1.start();
10
11 MyThread2 thread2 = new MyThread2(task);
12 thread2.start();
13
14 try {
15 Thread.sleep(10000);
16 } catch (InterruptedException e) {
17 e.printStackTrace();
18 }
19
20 long beginTime = CommonUtils.beginTime1;
21 if (CommonUtils.beginTime2 < CommonUtils.beginTime1) {
22 beginTime = CommonUtils.beginTime2;
23 }
24
25 long endTime = CommonUtils.endTime1;
26 if (CommonUtils.endTime2 > CommonUtils.endTime1) {
27 endTime = CommonUtils.endTime2;
28 }
29
30 System.out.println("耗时" + ((endTime - beginTime) / 1000) + " 秒");
31 }
32 }
结果
1 begin task 2 begin task 3 长时间处理任务后从远程返回的值1 threadName=Thread-1 4 长时间处理任务后从远程返回的值1 threadName=Thread-0 5 长时间处理任务后从远程返回的值2 threadName=Thread-0 6 长时间处理任务后从远程返回的值2 threadName=Thread-0 7 end task 8 end task 9 耗时3 秒
这里是用的synchronized代码锁，如果换成方法锁
所有代码不变，仅更改Task类
1 package com.weishiyao.learn.day4.testSynchorized.ep2;
2
3 public class Task {
4
5 private String getData1;
6 private String getData2;
7
8 public synchronized void doLongTimeTask() {
9 try {
10 System.out.println("begin task");
11 Thread.sleep(3000);
12 getData1 = "长时间处理任务后从远程返回的值1 threadName="
13 + Thread.currentThread().getName();
14 getData2 = "长时间处理任务后从远程返回的值2 threadName="
15 + Thread.currentThread().getName();
16 System.out.println(getData1);
17 System.out.println(getData2);
18 System.out.println("end task");
19 } catch (InterruptedException e) {
20 // TODO Auto-generated catch block
21 e.printStackTrace();
22 }
23 }
24 }
运行结果
1 begin task 2 长时间处理任务后从远程返回的值1 threadName=Thread-0 3 长时间处理任务后从远程返回的值2 threadName=Thread-0 4 end task 5 begin task 6 长时间处理任务后从远程返回的值1 threadName=Thread-1 7 长时间处理任务后从远程返回的值2 threadName=Thread-1 8 end task 9 耗时6 秒
可以得出结论，当一个线程访问object的synchronized同步代码块时，另一个线程依然可以访问非同步代码块，这样同步代码块就会比同步方法所花费更短的时间，可以得到更高的效率，在同步代码块中代码是同步的，不在同步代码块中代码是异步的。
二、synchronized代码块间的同步性
当一个线程访问object的一个synchronized(this)同步代码块时，其他线程对同一个object中所有其他synchronized(this)同步代码块的访问将被阻塞，因为synchronized使用的是一个“对象监视器”
ObjectService类
1 package com.weishiyao.learn.day4.testSynchorized.ep3;
2
3 public class ObjectService {
4
5 public void serviceMethodA() {
6 try {
7 synchronized (this) {
8 System.out
9 .println("A begin time=" + System.currentTimeMillis());
10 Thread.sleep(2000);
11 System.out
12 .println("A end end=" + System.currentTimeMillis());
13 }
14 } catch (InterruptedException e) {
15 e.printStackTrace();
16 }
17 }
18
19 public void serviceMethodB() {
20 synchronized (this) {
21 System.out.println("B begin time=" + System.currentTimeMillis());
22 System.out.println("B end end=" + System.currentTimeMillis());
23 }
24 }
25 }
ThreadA
1 package com.weishiyao.learn.day4.testSynchorized.ep3;
2
3 public class ThreadA extends Thread {
4
5 private ObjectService service;
6
7 public ThreadA(ObjectService service) {
8 super();
9 this.service = service;
10 }
11
12 @Override
13 public void run() {
14 super.run();
15 service.serviceMethodA();
16 }
17
18 }
ThreadB
1 package com.weishiyao.learn.day4.testSynchorized.ep3;
2
3 public class ThreadB extends Thread {
4 private ObjectService service;
5
6 public ThreadB(ObjectService service) {
7 super();
8 this.service = service;
9 }
10
11 @Override
12 public void run() {
13 super.run();
14 service.serviceMethodB();
15 }
16 }
Run
1 package com.weishiyao.learn.day4.testSynchorized.ep3;
2
3 public class Run {
4
5 public static void main(String[] args) {
6 ObjectService service = new ObjectService();
7
8 ThreadA a = new ThreadA(service);
9 a.setName("a");
10 a.start();
11
12 ThreadB b = new ThreadB(service);
13 b.setName("b");
14 b.start();
15 }
16
17 }
结果
1 A begin time=1459077186249 2 A end end=1459077188249 3 B begin time=1459077188249 4 B end end=1459077188249
三、静态同步synchronized方法与synchronized(class)代码块
关键字synchronized还可以用在static静态方法上，如果这样写，那是对当前的java对应的Class类进行上锁
Service类
1 package com.weishiyao.learn.day4.staticSynchorized;
2
3 public class Service {
4 synchronized public static void printA() {
5 try {
6 System.out.println("线程名称为：" + Thread.currentThread().getName() + "在" + System.currentTimeMillis() + "进入A");
7 Thread.sleep(3000);
8 System.out.println("线程名称为：" + Thread.currentThread().getName() + "在" + System.currentTimeMillis() + "离开A");
9 } catch (Exception e) {
10 e.printStackTrace();
11 }
12 }
13
14 synchronized public static void printB() {
15 try {
16 System.out.println("线程名称为：" + Thread.currentThread().getName() + "在" + System.currentTimeMillis() + "进入B");
17 Thread.sleep(3000);
18 System.out.println("线程名称为：" + Thread.currentThread().getName() + "在" + System.currentTimeMillis() + "离开B");
19 } catch (Exception e) {
20 e.printStackTrace();
21 }
22 }
23
24 synchronized public void printC() {
25 try {
26 System.out.println("线程名称为：" + Thread.currentThread().getName() + "在" + System.currentTimeMillis() + "进入C");
27 Thread.sleep(3000);
28 System.out.println("线程名称为：" + Thread.currentThread().getName() + "在" + System.currentTimeMillis() + "离开C");
29 } catch (Exception e) {
30 e.printStackTrace();
31 }
32 }
33 }
ThreadA
1 package com.weishiyao.learn.day4.staticSynchorized;
2
3 public class ThreadA extends Thread {
4 private Service service;
5
6 public ThreadA(Service service) {
7 super();
8 this.service = service;
9 }
10
11 @SuppressWarnings("static-access")
12 @Override
13 public void run() {
14 service.printA();
15 }
16 }
ThreadB、ThreadC类似ThreadA，不再列出
Run
1 package com.weishiyao.learn.day4.staticSynchorized;
2
3 public class Run {
4 public static void main(String[] args) {
5 Service service = new Service();
6 ThreadA threadA = new ThreadA(service);
7 threadA.setName("A");
8 threadA.start();
9 ThreadB threadB = new ThreadB(service);
10 threadB.setName("B");
11 threadB.start();
12 ThreadC threadC = new ThreadC(service);
13 threadC.setName("C");
14 threadC.start();
15 }
16 }
结果
1 线程名称为：A在1459078101483进入A 2 线程名称为：C在1459078101490进入C 3 线程名称为：A在1459078104484离开A 4 线程名称为：B在1459078104484进入B 5 线程名称为：C在1459078104491离开C 6 线程名称为：B在1459078107484离开B
分析运行结果，A和B是同步运行，C是异步运行，异步的原因是持有不同的锁，一个是对象锁，另外一个是Class锁。
同步synchronized(class)代码块的作用和synchronized static方法的作用一样。
四、内置类与同步
OutClass
1 package com.weishiyao.learn.day4.syncClass.ep5;
2
3 public class OutClass {
4 static class InnerClass1 {
5 public void method1(InnerClass2 class2) {
6 String threadName = Thread.currentThread().getName();
7 synchronized (class2) {
8 System.out.println(threadName
9 + " 进入InnerClass1类中的method1方法");
10 for (int i = 0; i < 10; i++) {
11 System.out.println("i=" + i);
12 try {
13 Thread.sleep(100);
14 } catch (InterruptedException e) {
15
16 }
17 }
18 System.out.println(threadName
19 + " 离开InnerClass1类中的method1方法");
20 }
21 }
22
23 public synchronized void method2() {
24 String threadName = Thread.currentThread().getName();
25 System.out.println(threadName + " 进入InnerClass1类中的method2方法");
26 for (int j = 0; j < 10; j++) {
27 System.out.println("j=" + j);
28 try {
29 Thread.sleep(100);
30 } catch (InterruptedException e) {
31
32 }
33 }
34 System.out.println(threadName + " 离开InnerClass1类中的method2方法");
35 }
36 }
37
38 static class InnerClass2 {
39 public synchronized void method1() {
40 String threadName = Thread.currentThread().getName();
41 System.out.println(threadName + " 进入InnerClass2类中的method1方法");
42 for (int k = 0; k < 10; k++) {
43 System.out.println("k=" + k);
44 try {
45 Thread.sleep(100);
46 } catch (InterruptedException e) {
47
48 }
49 }
50 System.out.println(threadName + " 离开InnerClass2类中的method1方法");
51 }
52 }
53 }
Run
1 package com.weishiyao.learn.day4.syncClass.ep5;
2
3 import com.weishiyao.learn.day4.syncClass.ep5.OutClass.InnerClass1;
4 import com.weishiyao.learn.day4.syncClass.ep5.OutClass.InnerClass2;
5
6 public class Run {
7
8 public static void main(String[] args) {
9 final InnerClass1 in1 = new InnerClass1();
10 final InnerClass2 in2 = new InnerClass2();
11 Thread t1 = new Thread(new Runnable() {
12 public void run() {
13 in1.method1(in2);
14 }
15 }, "T1");
16 Thread t2 = new Thread(new Runnable() {
17 public void run() {
18 in1.method2();
19 }
20 }, "T2");
21 Thread t3 = new Thread(new Runnable() {
22 public void run() {
23 in2.method1();
24 }
25 }, "T3");
26 t1.start();
27 t2.start();
28 t3.start();
29 }
30 }
结果
1 T2 进入InnerClass1类中的method2方法 2 T1 进入InnerClass1类中的method1方法 3 i=0 4 j=0 5 i=1 6 j=1 7 j=2 8 i=2 9 i=3 10 j=3 11 j=4 12 i=4 13 i=5 14 j=5 15 j=6 16 i=6 17 i=7 18 j=7 19 i=8 20 j=8 21 i=9 22 j=9 23 T2 离开InnerClass1类中的method2方法 24 T1 离开InnerClass1类中的method1方法 25 T3 进入InnerClass2类中的method1方法 26 k=0 27 k=1 28 k=2 29 k=3 30 k=4 31 k=5 32 k=6 33 k=7 34 k=8 35 k=9 36 T3 离开InnerClass2类中的method1方法
同步代码块synchronized(class2)对class2上锁后，其他线程只能以同步的方式调用class2中的静态同步方法
五、锁对象的改变
在将任何数据类型作为同步锁时，需要注意的是，是否有多个线程同时持有锁对象，如果同时持有相同的锁对象，则这些线程之间就是同步的；如果分别获得锁对象，这些线程之间就是异步的。
MyService
1 package com.weishiyao.learn.day4.syncClass.ep6;
2
3 public class MyService {
4 private String lock = "123";
5
6 public void testMethod() {
7 try {
8 synchronized (lock) {
9 System.out.println(Thread.currentThread().getName() + " begin "
10 + System.currentTimeMillis());
11 lock = "456";
12 Thread.sleep(2000);
13 System.out.println(Thread.currentThread().getName() + " end "
14 + System.currentTimeMillis());
15 }
16 } catch (InterruptedException e) {
17 e.printStackTrace();
18 }
19 }
20
21 }
ThreadA
1 package com.weishiyao.learn.day4.syncClass.ep6;
2
3 public class ThreadA extends Thread {
4
5 private MyService service;
6
7 public ThreadA(MyService service) {
8 super();
9 this.service = service;
10 }
11
12 @Override
13 public void run() {
14 service.testMethod();
15 }
16 }
ThreadB
package com.weishiyao.learn.day4.syncClass.ep6;
public class ThreadB extends Thread {
private MyService service;
public ThreadB(MyService service) {
super();
this.service = service;
}
@Override
public void run() {
service.testMethod();
}
}
Run1
1 package com.weishiyao.learn.day4.syncClass.ep6;
2
3 public class Run1 {
4
5 public static void main(String[] args) throws InterruptedException {
6
7 MyService service = new MyService();
8
9 ThreadA a = new ThreadA(service);
10 a.setName("A");
11
12 ThreadB b = new ThreadB(service);
13 b.setName("B");
14
15 a.start();
16 Thread.sleep(50);
17 b.start();
18 }
19 }
结果
1 A begin 1459080143796 2 B begin 1459080143846 3 A end 1459080145797 4 B end 1459080145846
因为50毫秒之后a取得的是锁"456"
重新改一下Run类
1 package com.weishiyao.learn.day4.syncClass.ep6;
2
3 public class Run2 {
4
5 public static void main(String[] args) throws InterruptedException {
6
7 MyService service = new MyService();
8
9 ThreadA a = new ThreadA(service);
10 a.setName("A");
11
12 ThreadB b = new ThreadB(service);
13 b.setName("B");
14
15 a.start();
16 b.start();
17 }
18 }
结果
1 A begin 1459080318782 2 A end 1459080320782 3 B begin 1459080320782 4 B end 1459080322783
只要对象不变，即使对象的属性被改变，运行结果还是同步的
Service
1 package com.weishiyao.learn.day4.syncClass.ep7;
2
3 public class Service {
4
5 public void serviceMethodA(Userinfo userinfo) {
6 synchronized (userinfo) {
7 try {
8 System.out.println(Thread.currentThread().getName());
9 userinfo.setUsername("abcabcabc");
10 Thread.sleep(3000);
11 System.out.println("end! time=" + System.currentTimeMillis());
12 } catch (InterruptedException e) {
13 e.printStackTrace();
14 }
15 }
16 }
17 }
Userinfo
1 package com.weishiyao.learn.day4.syncClass.ep7;
2
3 public class Userinfo {
4 private String username;
5 private String password;
6
7 public Userinfo() {
8 super();
9 }
10
11 public Userinfo(String username, String password) {
12 super();
13 this.username = username;
14 this.password = password;
15 }
16
17 public String getUsername() {
18 return username;
19 }
20
21 public void setUsername(String username) {
22 this.username = username;
23 }
24
25 public String getPassword() {
26 return password;
27 }
28
29 public void setPassword(String password) {
30 this.password = password;
31 }
32
33 }
ThreadA
1 package com.weishiyao.learn.day4.syncClass.ep7;
2
3 public class ThreadA extends Thread {
4
5 private Service service;
6 private Userinfo userinfo;
7
8 public ThreadA(Service service,
9 Userinfo userinfo) {
10 super();
11 this.service = service;
12 this.userinfo = userinfo;
13 }
14
15 @Override
16 public void run() {
17 service.serviceMethodA(userinfo);
18 }
19
20 }
ThreadB
1 package com.weishiyao.learn.day4.syncClass.ep7;
2
3 public class ThreadB extends Thread {
4
5 private Service service;
6 private Userinfo userinfo;
7
8 public ThreadB(Service service,
9 Userinfo userinfo) {
10 super();
11 this.service = service;
12 this.userinfo = userinfo;
13 }
14
15 @Override
16 public void run() {
17 service.serviceMethodA(userinfo);
18 }
19
20 }
运行类
1 package com.weishiyao.learn.day4.syncClass.ep7;
2
3 public class Run {
4
5 public static void main(String[] args) {
6
7 try {
8 Service service = new Service();
9 Userinfo userinfo = new Userinfo();
10
11 ThreadA a = new ThreadA(service, userinfo);
12 a.setName("a");
13 a.start();
14 Thread.sleep(50);
15 ThreadB b = new ThreadB(service, userinfo);
16 b.setName("b");
17 b.start();
18
19 } catch (InterruptedException e) {
20 e.printStackTrace();
21 }
22
23 }
24 }
结果
1 a 2 end! time=1459080585999 3 b 4 end! time=1459080589000
时间： 2024-10-18 18:57:08