标签：imp 名称 end super stat ide time star 访问
多个线程访问同一个类的synchronized方法时, 都是串行执行的 ! 就算有多个cpu也不例外 ! synchronized方法使用了类java的内置锁, 即锁住的是方法所属对象本身. 同一个锁某个时刻只能被一个执行线程所获取, 因此其他线程都得等待锁的释放. 因此就算你有多余的cpu可以执行, 但是你没有锁, 所以你还是不能进入synchronized方法执行, CPU因此而空闲. 如果某个线程长期持有一个竞争激烈的锁, 那么将导致其他线程都因等待所的释放而被挂起, 从而导致CPU无法得到利用, 系统吞吐量低下.甚至导致死锁的产生， 因此要尽量避免某个线程对锁的长期占有 !
方法声明时使用，即一次只能有一个线程进入该方法，其他线程要想在此时调用该方法，只能排队等候
public synchronized void synMethod() {
//方法体
}public class SyncMethod {
public synchronized void syncMethod2() {
try {
System.out.println("@@@@@@@@@@@@@@@@@@@@@@@@ (syncMethod2, 已经获取内置锁`SyncMethod.this`)");
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("@@@@@@@@@@@@@@@@@@@@@@@@ (syncMethod2, 即将释放内置锁`SyncMethod.this`)");
}
public synchronized void syncMethod1() {
System.out.println("######################## (syncMethod1, 已经获取内置锁`SyncMethod.this`, 并即将退出)");
}
static class Thread1 extends Thread {
SyncMethod syncMethod;
public Thread1(SyncMethod syncMethod) {
this.syncMethod = syncMethod;
}
@Override
public void run() {
syncMethod.syncMethod2();
}
}
static class Thread2 extends Thread {
SyncMethod syncMethod;
public Thread2(SyncMethod syncMethod) {
this.syncMethod = syncMethod;
}
@Override
public void run() {
System.out.println("Thread2 running ...");
syncMethod.syncMethod1();
}
}
public static void main(String[] args) throws InterruptedException {
SyncMethod syncMethod = new SyncMethod();
Thread1 thread1 = new Thread1(syncMethod);
Thread2 thread2 = new Thread2(syncMethod);
thread1.start(); //先执行, 以便抢占锁
Thread.sleep(500); //放弃cpu, 让thread1执行, 以便获的锁
thread2.start(); //在syncMethod1()方法获得锁时, 看看syncMethod2()方法能否执行
}
}console打印：
@@@@@@@@@@@@@@@@@@@@@@@@ (syncMethod2, 已经获取内置锁`SyncMethod.this`)
Thread2 running ...
@@@@@@@@@@@@@@@@@@@@@@@@ (syncMethod2, 即将释放内置锁`SyncMethod.this`)
######################## (syncMethod1, 已经获取内置锁`SyncMethod.this`, 并即将退出)上述代码synchronized修饰的方法，锁住的是类的实例化对象syncMethod，所以Thread1执行syncMethod2的方法将syncMethod对象锁住，使得Thread2受到阻塞必须在Thread1释放锁之后才能执行syncMethod1方法。
将上述代码中的Main方法修改如下：
SyncMethod syncMethod1 = new SyncMethod();
SyncMethod syncMethod2 = new SyncMethod();
Thread1 thread1 = new Thread1(syncMethod1);
Thread2 thread2 = new Thread2(syncMethod2);
thread1.start();
Thread.sleep(500);
thread2.start();
console打印：
@@@@@@@@@@@@@@@@@@@@@@@@ (syncMethod2, 已经获取内置锁`SyncMethod.this`)
Thread2 running ...
######################## (syncMethod1, 已经获取内置锁`SyncMethod.this`, 并即将退出)
@@@@@@@@@@@@@@@@@@@@@@@@ (syncMethod2, 即将释放内置锁`SyncMethod.this`)上述代码中Thread1锁的是syncMethod1对象，而Thread2锁的是syncMethod2对象，所以Thread1线程执行syncMethod2并不会阻塞Thread2
当然还有第二种改进措施：
public class SyncObject {
private Object lock1 = new Object();
private Object lock2 = new Object();
public void syncMethod2() {
synchronized (lock1) {
try {
System.out.println("@@@@@@@@@@@@@@@@@@@@@@@@ (syncMethod2, 已经获取内置锁`SyncMethod.this`)");
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("@@@@@@@@@@@@@@@@@@@@@@@@ (syncMethod2, 即将释放内置锁`SyncMethod.this`)");
}
}
public void syncMethod1() {
synchronized (lock2) {
System.out.println("######################## (syncMethod1, 已经获取内置锁`SyncMethod.this`, 并即将退出)");
}
}
static class Thread1 extends Thread {
SyncObject syncObject;
public Thread1(SyncObject syncObject) {
this.syncObject = syncObject;
}
@Override
public void run() {
syncObject.syncMethod2();
}
}
static class Thread2 extends Thread {
SyncObject syncObject;
public Thread2(SyncObject syncObject) {
this.syncObject = syncObject;
}
@Override
public void run() {
System.out.println("Thread2 running ...");
syncObject.syncMethod1();
}
}
public static void main(String[] args) throws InterruptedException {
SyncObject syncObject = new SyncObject();
Thread1 thread1 = new Thread1(syncObject);
Thread2 thread2 = new Thread2(syncObject);
thread1.start(); //先执行, 以便抢占锁
Thread.sleep(500); //放弃cpu, 让thread1执行, 以便获的锁
thread2.start(); //在syncMethod1()方法获得锁时, 看看syncMethod2()方法能否执行
}
}下面是一些关于使用锁的一些建议: 为了避免对锁的竞争, 你可以使用锁分解,锁分段以及减少线程持有锁的时间, 如果上诉程序中的syncMethod1和syncMethod2方法是两个不相干的方法(请求的资源不存在关系), 那么这两个方法可以分别使用两个不同的锁。
上面Thread1锁的是对象lock1，而Thread2锁的是对象lock2。
public synchronized static void method() {
// todo
}我们知道静态方法是属于类的而不属于对象的。同样的，synchronized修饰的静态方法锁定的是这个类的所有对象。我们对第一节的Demo进行一些修改如下：
class SyncThread implements Runnable {
private static int count;
public SyncThread() {
count = 0;
}
public synchronized static void method() {
for (int i = 0; i < 5; i ++) {
try {
System.out.println(Thread.currentThread().getName() + ":" + (count++));
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public synchronized void run() {
method();
}
}
public static void main(String[] args) {
SyncStatic syncThread1 = new SyncStatic();
SyncStatic syncThread2 = new SyncStatic();
Thread thread1 = new Thread(syncThread1, "SyncThread1");
Thread thread2 = new Thread(syncThread2, "SyncThread2");
thread1.start();
thread2.start();
}console打印：
SyncThread1:0
SyncThread1:1
SyncThread1:2
SyncThread1:3
SyncThread1:4
SyncThread2:5
SyncThread2:6
SyncThread2:7
SyncThread2:8
SyncThread2:9印证了我们刚开始说的
synchronized修饰的静态方法锁定的是这个类的所有对象
当两个并发线程(thread1和thread2)访问同一个对象(syncThread)中的synchronized代码块时，在同一时刻只能有一个线程得到执行，另一个线程受阻塞，必须等待当前线程执行完这个代码块以后才能执行该代码块。Thread1和thread2是互斥的，因为在执行synchronized代码块时会锁定当前的对象，只有执行完该代码块才能释放该对象锁，下一个线程才能执行并锁定该对象。
class SyncThread implements Runnable {
private static int count;
public SyncThread() {
count = 0;
}
public void run() {
synchronized(this) {
for (int i = 0; i < 5; i++) {
try {
System.out.println(Thread.currentThread().getName() + ":" + (count++));
Thread.sleep(100);
//this.wait(100);释放锁，其他线程可以执行
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public int getCount() {
return count;
}
}
//main函数调用
SyncThread的调用：
SyncThread syncThread = new SyncThread();
Thread thread1 = new Thread(syncThread, "SyncThread1");
Thread thread2 = new Thread(syncThread, "SyncThread2");
thread1.start();
thread2.start();console打印：
SyncThread1:0
SyncThread1:1
SyncThread1:2
SyncThread1:3
SyncThread1:4
SyncThread2:5
SyncThread2:6
SyncThread2:7
SyncThread2:8
SyncThread2:9值得注意的是：
当一个线程访问对象的一个synchronized(this)同步代码块时，另一个线程仍然可以访问该对象中的非synchronized(this)同步代码块。
给指定的对象加锁：
public void method(SomeObject obj)
{
//obj 锁定的对象
synchronized(obj)
{
// todo
}
}public class SyncClass {
public void methodA(){
try {
synchronized (SyncClass.class){
System.out.println("methodA begin 线程名称："+Thread.currentThread().getName()+"times:"+System.currentTimeMillis());
Thread.sleep(3000);
System.out.println("methodA end 线程名称："+Thread.currentThread().getName()+"times:"+System.currentTimeMillis());
}
}catch (InterruptedException e){
e.printStackTrace();
}
}
public void methodB(){
synchronized (SyncClass.class){
System.out.println("methodB begin 线程名称："+Thread.currentThread().getName()+"times:"+System.currentTimeMillis());
System.out.println("methodB end 线程名称："+Thread.currentThread().getName()+"times:"+System.currentTimeMillis());
}
}
static class Thread1 extends Thread {
private SyncClass syncClass;
public Thread1(SyncClass syncClass) {
super();
this.syncClass = syncClass;
}
@Override
public void run() {
syncClass.methodA();
}
}
static class Thread2 extends Thread {
private SyncClass syncClass;
public Thread2(SyncClass syncClass) {
super();
this.syncClass = syncClass;
}
@Override
public void run() {
syncClass.methodB();
}
}
public static void main(String[] args) {
SyncClass syncClass1 = new SyncClass();
SyncClass syncClass2 = new SyncClass();
Thread1 thread1=new Thread1(syncClass1);
Thread2 thread2 = new Thread2(syncClass2);
thread1.setName("A");
thread2.setName("B");
thread1.start();
thread2.start();
}
}console打印：
methodA begin 线程名称：Atimes:1533208268430
methodA end 线程名称：Atimes:1533208271431
methodB begin 线程名称：Btimes:1533208271431
methodB end 线程名称：Btimes:1533208271431由打印结果以及与第一节改进1结果相比可得结论：
synchronized作用于一个类T时，是给这个类T加锁，T的所有实例化对象用的是同一把锁。
所以才会出现methodB在等methodA执行完毕才执行，收到阻塞。
将一个synchronized静态代码块反编译会看到两个专有名词
monitorenter
每个对象有一个监视器锁（monitor）。当monitor被占用时就会处于锁定状态，线程执行monitorenter指令时尝试获取monitor的所有权，过程如下：
1、如果monitor的进入数为0，则该线程进入monitor，然后将进入数设置为1，该线程即为monitor的所有者。
2、如果线程已经占有该monitor，只是重新进入，则进入monitor的进入数加1.
3.如果其他线程已经占用了monitor，则该线程进入阻塞状态，直到monitor的进入数为0，再重新尝试获取monitor的所有权。
monitorexit:
执行monitorexit的线程必须是objectref所对应的monitor的所有者。
指令执行时，monitor的进入数减1，如果减1后进入数为0，那线程退出monitor，不再是这个monitor的所有者。其他被这个monitor阻塞的线程可以尝试去获取这个 monitor 的所有权。
总结：
通过这两段描述，我们应该能很清楚的看出Synchronized的实现原理，Synchronized的语义底层是通过一个monitor的对象来完成，其实wait/notify等方法也依赖于monitor对象，这就是为什么只有在同步的块或者方法中才能调用wait/notify等方法，否则会抛出java.lang.IllegalMonitorStateException的异常的原因。
将一个synchronized同步方法反编译：
ACC_SYNCHRONIZED：
从反编译的结果来看，方法的同步并没有通过指令monitorenter和monitorexit来完成（理论上其实也可以通过这两条指令来实现），不过相对于普通方法，其常量池中多了ACC_SYNCHRONIZED标示符。JVM就是根据该标示符来实现方法的同步的：当方法调用时，调用指令将会检查方法的 ACC_SYNCHRONIZED 访问标志是否被设置，如果设置了，执行线程将先获取monitor，获取成功之后才能执行方法体，方法执行完后再释放monitor。在方法执行期间，其他任何线程都无法再获得同一个monitor对象。 其实本质上没有区别，只是方法的同步是一种隐式的方式来实现，无需通过字节码来完成。
标签：imp 名称 end super stat ide time star 访问
原文地址：https://www.cnblogs.com/sxkgeek/p/9415818.html
