JAVA多线程 --- Synchronized

Synchronized基本使用

Synchronized(this)
锁是当前对象，多个线程同时执行方法块时，任意一个线程拿到这个对象锁。执行完代码块，释放锁，另外的线程才有获取到锁的权利，拿到锁，才能执行此代码块

如果多个线程访问的是多个不同的对象的方法，那么就不会串行执行，因为他们的当前对象（this）不同

都可以拿到自己的对象锁

class SynchronizedForThis implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
        synchronized (this){
            System.out.println("我是线程 "+Thread.currentThread().getName());
            try{
                Thread.sleep(3000);
            }catch (InterruptedException e){
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "结束");
        }
    }
}
static SynchronizedForThis example = new SynchronizedForThis();

public static void main(String[] args) {
        Thread t1 = new Thread(example);
        Thread t2 = new Thread(example);
        t1.start();
        t2.start();

    }

synchronized (object1)

锁也可以是任意对象，针对同一的对象，不同线程拿到这一对象锁就可执行

object1 和 object2 不是同一对象，当第一个线程拿到object1锁，执行完毕

此时第一个线程去拿object2锁，其他线程抢占object1,拿到的线程可以执行object1锁代码块

class SynchronizedForObject implements Runnable{
    Object object1 = new Object();
    Object object2 = new Object();
    @Override
    public void run() {
        synchronized (object1){
            System.out.println("object1锁，我是线程" + Thread.currentThread().getName());
            try {
                Thread.sleep(3000);
            }catch (InterruptedException e){
                e.printStackTrace();
            }
            System.out.println("object1锁，"+Thread.currentThread().getName() + "结束");
        }

        synchronized (object2){
            System.out.println("object2锁，我是线程" + Thread.currentThread().getName());
            try {
                Thread.sleep(3000);
            }catch (InterruptedException e){
                e.printStackTrace();
            }
            System.out.println("object2锁，"+Thread.currentThread().getName() + "结束");
        }

    }
}

static SynchronizedForObject example = new SynchronizedForObject();
public static void main(String[] args) {
    Thread t1 = new Thread(example);
    Thread t2 = new Thread(example);
    t1.start();
    t2.start();

}

 

synchronized 修饰方法，锁是this,锁住的是整个方法的代码块

class SynchronizedForMethod implements Runnable{
    @Override
    public void run() {
        method();
    }
    public synchronized void method(){
        System.out.println("我是线程 "+Thread.currentThread().getName());
        try{
            Thread.sleep(3000);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+ "结束");
    }
}

Synchronized 修饰静态（static）方法，锁是这个class

就算是这个类的多个对象，只能由一个线程拿到这个锁（因为他们都属于这一个类）

class SynchronizedForStatic implements Runnable{
    @Override
    public void run() {
        method2();
    }
    public synchronized static void method2(){
        System.out.println("我是线程 "+Thread.currentThread().getName());
        try{
            Thread.sleep(3000);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+ "结束");

    }
}
static SynchronizedForStatic example = new SynchronizedForStatic();

static SynchronizedForStatic example2 = new SynchronizedForStatic();

public static void main(String[] args) {
    Thread t1 = new Thread(example);
    Thread t2 = new Thread(example2);
    t1.start();
    t2.start();

}

 

synchronized (类名.class)

锁是这个类，任意时刻，只能由一个线程拿到这个锁

class SynchronizedForClass implements Runnable{
    @Override
    public void run() {
        synchronized (SynchronizedForClass.class){
            System.out.println("我是线程 "+Thread.currentThread().getName());
            try{
                Thread.sleep(3000);
            }catch (InterruptedException e){
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+ "结束");
        }
    }
}

 

Synchronized实现原理

CAS

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

。