synchnionzed的两种用法

在并发编程领域3个重要的问题

分工问题

同步问题

互斥问题

synnchroinzed的使用：

1、同步代码块：

synchronized(this（锁的对象）|Object及其子类（必须是类对象）|类名称.class（反射对象）){

//此时代码块在任意一个时刻只能由一个线程进入

}

类名称.class是反射对象，只能取得，不能自己生成，在第一次用到这个类时，JVM就会生成他，每个类只有一个

2、同步方法（默认锁的是this：当前对象）：直接在方法声明上使用synchronized，此时表示同步方法在任意时刻只能有一个线程进入

          2.1、修饰普通的对象方法，锁当前对象this

          2.2、修饰的静态方法，锁当前类.class

 

 

锁：一把锁保护一个相应资源，不同锁保护的不同的对象/资源

Java中锁的实现：使用synnchroinzed关键字为程序逻辑上锁

如果有一个买票系统，不上锁会有什么影响：

public class BuyTicket {
    public static void main(String[] args){
        Ticket ticket = new Ticket();
        Thread thread1 = new Thread(ticket);
        Thread thread2 = new Thread(ticket);
        Thread thread3 = new Thread(ticket);
        thread1.start();
        thread2.start();
        thread3.start();
    }
}

class Ticket implements Runnable{

    private int ticket = 20;
    @Override
    public void run() {
         //如果这时ticket=1，如果现在线程0进入了循环，正在执行Thread.sleep(200);，这是线程//1，2检测到ticket还是为1，所以他们都进入了循环中，执行--ticket，所以票就有可能出现-2的情况，然//而这是不符合现实情况的
        while(this.ticket>0){  
            try {
                Thread.sleep(200);//模拟网络延时
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"  还剩下"+--ticket+"张票");
        }
    }
}


/*
    运行结果
    Thread-0  还剩下19张票
Thread-1  还剩下18张票
Thread-2  还剩下17张票
Thread-0  还剩下16张票
Thread-1  还剩下15张票
Thread-2  还剩下14张票
Thread-0  还剩下13张票
Thread-1  还剩下12张票
Thread-2  还剩下11张票
Thread-0  还剩下10张票
Thread-1  还剩下8张票
Thread-2  还剩下9张票
Thread-0  还剩下7张票
Thread-2  还剩下6张票
Thread-1  还剩下5张票
Thread-0  还剩下4张票
Thread-2  还剩下3张票
Thread-1  还剩下2张票
Thread-0  还剩下1张票
Thread-2  还剩下0张票
Thread-1  还剩下-1张票
Thread-0  还剩下-2张票    
*/

使用synchroinzed的两种用法：

同步代码块：

synchronized(this锁的对象|Object及其子类（必须是类对象）|当前类.class){

//此时代码块在任意一个时刻只能由一个线程进入

}

synchronized是对象锁：this锁的对象|Object及其子类（必须是类对象）|当前类.class这三个都是对象

 

synchronized锁住的是当前的对象，在下面的代码中，锁的就是Ticket类的实例化对象ticket（代码中ticket对象只有一个）。

public class BuyTicket {
    public static void main(String[] args){
        Ticket ticket = new Ticket();
        Thread thread1 = new Thread(ticket);
        Thread thread2 = new Thread(ticket);
        Thread thread3 = new Thread(ticket);
        thread1.start();
        thread2.start();
        thread3.start();
    }
}

class Ticket implements Runnable{

    private int ticket = 20;
    @Override
    public void run() {
        while(ticket>0){
            synchronized(this){
                if(ticket>0){
                    try {
                        Thread.sleep(200);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+"  还剩下"+--ticket+"张票");
                }
            }
        }
    }
}

/*
    运行结果
    Thread-0  还剩下19张票
Thread-2  还剩下18张票
Thread-2  还剩下17张票
Thread-2  还剩下16张票
Thread-2  还剩下15张票
Thread-2  还剩下14张票
Thread-2  还剩下13张票
Thread-1  还剩下12张票
Thread-1  还剩下11张票
Thread-1  还剩下10张票
Thread-1  还剩下9张票
Thread-1  还剩下8张票
Thread-1  还剩下7张票
Thread-1  还剩下6张票
Thread-1  还剩下5张票
Thread-1  还剩下4张票
Thread-1  还剩下3张票
Thread-1  还剩下2张票
Thread-1  还剩下1张票
Thread-1  还剩下0张票
*/

同步方法（默认锁的是this：当前对象）：直接在方法声明上使用synchronized，此时表示同步方法在任意时刻只能有一个线程进入。

1、修饰普通的对象方法，锁当前对象this

2、修饰的静态方法，锁当前类.class

锁的是Ticket类的实例化对象ticket（代码中ticket对象只有一个）

public class BuyTicket {
    public static void main(String[] args){
        Ticket ticket = new Ticket();
        Thread thread1 = new Thread(ticket);
        Thread thread2 = new Thread(ticket);
        Thread thread3 = new Thread(ticket);
        thread1.start();
        thread2.start();
        thread3.start();
    }
}

class Ticket implements Runnable{

    private int ticket = 20;
    @Override
    public void run() {
        while(this.ticket>0){
            sellTicket();
        }

    }

    private synchronized void sellTicket() {
        if(ticket>0){
            System.out.println(Thread.currentThread().getName()+"  还剩下"+--ticket+"张票");
        }
    }
}

/*
运行结果：
Thread-0  还剩下19张票
Thread-0  还剩下18张票
Thread-0  还剩下17张票
Thread-0  还剩下16张票
Thread-2  还剩下15张票
Thread-2  还剩下14张票
Thread-2  还剩下13张票
Thread-2  还剩下12张票
Thread-2  还剩下11张票
Thread-2  还剩下10张票
Thread-2  还剩下9张票
Thread-2  还剩下8张票
Thread-2  还剩下7张票
Thread-2  还剩下6张票
Thread-2  还剩下5张票
Thread-2  还剩下4张票
Thread-2  还剩下3张票
Thread-2  还剩下2张票
Thread-2  还剩下1张票
Thread-2  还剩下0张票
*/

  

synchronized对象锁 

若synchronized修饰的是静态方法或synchronized（类名称.class-->反射对象：在JVM中有且只有一个） 

synchronized锁的都是当前类的反射对象（全局唯一） 

以下代码有三把锁、，因为有三个对象创建了3把锁

public class SyncTest {
    public static void main(String[] args) {
        Sync sync = new Sync();
        Thread thread1 = new Thread(sync);
        Thread thread2 = new Thread(sync);
        Thread thread3 = new Thread(sync);
        thread1.start();
        thread2.start();
        thread3.start();
    }
}

class Sync implements Runnable{
    @Override
    public void run() {
        Printf printf = new Printf();//每一个线程都会创建一个Printf对象，一共创建了3个对象
        printf.p();//p()为同步方法，但是这是有3个对象，每个对象都持有自己的一把锁
    }
}


class Printf{
    public synchronized void p(){//p()为同步方法
        System.out.println("正在打印...");
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("打印结束");
    }
}

   运行结果：这说明3个线程是一起进入方法中的，锁并没有成功。

这是因为每一个线程都会创建一个Printf对象，一共创建了3个对象，这3个对象，每个对象都持有自己的一把锁。可以进入自己的同步方法中。打个比方就像保险箱（把类理解为保险箱，把创建一个对象理解为买一个保险箱放到家里），前面的程序是有三个线程，但一共持有一个Runnsble对象---->有3个人买了一个保险箱，每次只能由一个人用保险箱。而这个程序时3个人有3个保险箱，互相之间不影响。

那要怎么写才能成为一个对象呢？

第一种方法：

将创建对象移到类的属性中去，这样只会创建一个对象

就像这样

class Sync implements Runnable{
    Printf printf = new Printf();
    @Override
    public void run() {
        printf.p();
    }
}

运行结果：

第二种方法：在方法中添加static关键字，将他变为静态方法

class Printf{
    public static synchronized void p(){
        System.out.println("正在打印...");
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("打印结束");
    }
}