Java同步线程synchronized用法

Java同步线程synchronized用法

线程同步，多个线程访问同一个资源，并且有的线程还要修改对象，这时候我们就需要用到线程同步，
他其实是一种等待机制，多个需要同时访问该对象的线程进入该对象的等待池，形成队列

锁机制 synchronized 当一个线程获得对象的排它锁，独占资源，其他线程必须等待，使用后，释放锁即可。
同步方法2种用法：
synchronized方法 若一个大的方法申明为synchronized将影响效率
和synchronized块

带来的问题
 1.一个线程持有锁，会导致其他所有需要此锁的线程挂起。
 2.多线程竞争下，加锁、释放锁会导致比较多的上下文切换和调度延时，引起性能下降
 3.如果一个线程优先级高的线程等待一个线程优先级低得线程释放锁，会导致优先级倒挂，引起性能问题。

public class BuyTicket  implements Runnable{

    //不安全的买票方法，出现负数，一票2卖的情况
    private static int ticketNum=10;
    boolean flag=true;
    @Override
    public void run() {
        while (flag){
            try {
                buy();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    //买票
    private void buy()throws InterruptedException{
        if(ticketNum<=0){//票数大于0可以买票
            flag=false;
            return;
        }
        Thread.sleep(100);
        int a=ticketNum--;
        System.out.println("["+Thread.currentThread().getName()+"]买到了第"+a+"张票");
        }



    public static void main(String[] args) {
        BuyTicket bt=new BuyTicket();
        Thread t1=new Thread(bt,"张三");
        Thread t2=new Thread(bt,"李四");
        Thread t3=new Thread(bt,"王五");
        t1.start();
        t2.start();
        t3.start();
    }
}

结果：出现负数，一票2卖的情况，很明显不安全

[李四]买到了第9张票
[张三]买到了第8张票
[王五]买到了第10张票
[王五]买到了第7张票
[张三]买到了第6张票
[李四]买到了第5张票
[李四]买到了第4张票
[张三]买到了第3张票
[王五]买到了第2张票
[张三]买到了第0张票
[李四]买到了第-1张票
[王五]买到了第1张票

synchronized同步方法

public class BuyTicket  implements Runnable{

    //安全的买票方法，不会出现负数，不会出现一票2卖的情况
    private static int ticketNum=10;
    boolean flag=true;
    @Override
    public void run() {
        while (flag){
            try {
                buy();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    //买票
    //private void buy()throws InterruptedException{
     private synchronized void buy()throws InterruptedException{//同步方法
        if(ticketNum<=0){//票数大于0可以买票
            flag=false;
            return;
        }
        Thread.sleep(100);
        int a=ticketNum--;
        System.out.println("["+Thread.currentThread().getName()+"]买到了第"+a+"张票");
        }



    public static void main(String[] args) {
        BuyTicket bt=new BuyTicket();
        Thread t1=new Thread(bt,"张三");
        Thread t2=new Thread(bt,"李四");
        Thread t3=new Thread(bt,"王五");
        t1.start();
        t2.start();
        t3.start();
    }
}

结果：

[张三]买到了第10张票
[王五]买到了第9张票
[李四]买到了第8张票
[李四]买到了第7张票
[王五]买到了第6张票
[张三]买到了第5张票
[王五]买到了第4张票
[李四]买到了第3张票
[王五]买到了第2张票
[张三]买到了第1张票

 

synchronized同步代码块

public class BuyTicket  implements Runnable{

    //安全的买票方法，不会出现负数，不会出现一票2卖的情况
    private static int ticketNum=10;
    boolean flag=true;
    @Override
    public void run() {
        while (flag){
            try {
               synchronized (this){
                    buy();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    //买票
    private void buy()throws InterruptedException{
        if(ticketNum<=0){//票数大于0可以买票
            flag=false;
            return;
        }
        Thread.sleep(100);
        int a=ticketNum--;
        System.out.println("["+Thread.currentThread().getName()+"]买到了第"+a+"张票");
        }



    public static void main(String[] args) {
        BuyTicket bt=new BuyTicket();
        Thread t1=new Thread(bt,"张三");
        Thread t2=new Thread(bt,"李四");
        Thread t3=new Thread(bt,"王五");
        t1.start();
        t2.start();
        t3.start();
    }
}

结果：

[张三]买到了第10张票
[王五]买到了第9张票
[李四]买到了第8张票
[王五]买到了第7张票
[张三]买到了第6张票
[王五]买到了第5张票
[李四]买到了第4张票
[王五]买到了第3张票
[王五]买到了第2张票
[张三]买到了第1张票