JAVA基础----初入多线程基础学习总结

(多线程操作同一个资源)的并发问题

• 线程同步
  锁机制可能引发的问
• 1.一个线程持有锁会导致其他所有需要次所的线程挂起
• 2.在多线程竞争下,加锁和释放锁会导致比较多的上下文切换和调度延时,引发性能问题
• 3.如果一个优先级高的线程等待一个优先级低的线程释放锁,会导致优先级倒置,引发性能问题—性能倒置

*synchronized关键字的两种用法:synchronized方法和synchronized块

• 同步方法:synchronized方法
• 每个对象都有一把锁,每个synchronized方法都必须获得调用该方法的对象的锁才能执行,否则线程阻塞
• 方法一旦执行,就独占该锁,知道该方法返回才释放锁,后面被阻塞的线程才能获得这个锁,从而继续执行
• public synchronized void method(){}
• 同步代码块:synchronized(obj){}
• obj同步监视器,
• 可以是任意对象,但是推荐使用共享资源作为同步监视器,通俗点说,就是操作那个对象做增删改,就拿着对象做同步监视器
• 同步方法中无须指定同步监视器,因为同步方法的同步监视器默认就是this也就是这个对象本身,或者是class

//同步方法
public class UnsafeTicket{
    public static void main(String[] args) {
        BuyTicket buyTicket=new BuyTicket();

        new  Thread(buyTicket,"张雨qi").start();
        new  Thread(buyTicket,"Eden").start();
        new  Thread(buyTicket,"张天ai").start();

    }
}
 class BuyTicket implements Runnable{
    private  int ticketNums=10;
    private  boolean flag=true;

    @Override
    public void run() {
        while (flag){
            try {
                buy();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    private synchronized void buy() throws InterruptedException {
        if(ticketNums<=0){
            flag=false;
            return;
        }
        Thread.sleep(100);
        System.out.println(Thread.currentThread().getName()+"买了第"+ticketNums--+"票");
    }
}

//同步代码块

public class UnSafeBank {
    public static void main(String[] args) {
        Account account = new Account(1000, "二套房基金");

        Drawing you = new Drawing(account, 50, "你自己");
        Drawing girlFriend = new Drawing(account, 100, "girlFriend");

        you.start();
        girlFriend.start();
    }
}


class Account {
    int money;
    String name;

    public Account(int money, String name) {
        this.money = money;
        this.name = name;
    }
}


class Drawing extends Thread {
    Account account;
    int drawingMoney;
    int nowMoney;

    public Drawing(Account account, int drawingMoney, String name) {
        super(name);
        this.account = account;
        this.drawingMoney = drawingMoney;
    }

    @Override
    public void run() {
        synchronized (account) {
            if (account.money - drawingMoney < 0) {
                System.out.println(Thread.currentThread().getName() + "余额不足");
                return;
            }
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            account.money = account.money - drawingMoney;
            nowMoney = nowMoney + drawingMoney;

            System.out.println(account.name + "余额为:" + account.money);
            System.out.println(this.getName() + "现金有:" + nowMoney);
        }
    }
}

• 死锁:多个线程持有对方需要的资源,然后形成僵持的情形
• 多个线程各种占用一些共享资源,并且互相等待其他线程占有的资源才能运行,而两个或者多个线程都在等待对方释放资源,都停止执行的情形.
• 某一个同步代码块同事拥有"两个以上对象"的锁,就可能会发生死锁的问题
• 产生死锁的四个必要条件:
• 1.互斥条件;一个资源每次只能被一个线程使用
• 2.请求和保持条件:一个线程因请求资源而阻塞时,对已经获得的资源保持不放
• 3.不剥夺条件:线程已经获得的资源,在为使用完之前,不能强行剥夺
• 4.循环等待条件:若干线程之间形成一种头尾相接的循环等待资源关系
• lock锁,显示定义的同步锁 jdk5开始推出
• Lock接口
• ReentrantLock类实现了Lock接口,可重入锁
• 拥有和synchronized相同的并发性和内存语义,较为常用,因为可以显示加锁,和释放锁
• synchronized和lock的对比
• 1.Lock锁是显示锁,需要手动加锁和释放;synchronized是隐式锁,出了作用域后自动释放
• 2.Lock只有代码块锁;synchronized有代码块锁和方法锁
• 3.使用Lock锁,JVM将花费较少的时间来调度小城,性能更好,并且具有更好的扩展性