回顾多线程

1.线程有几种状态

 public enum State {
      //新生
        NEW,

       //运行
        RUNNABLE,

      //阻塞
        BLOCKED,

      //等待
        WAITING,

       //超时等待
        TIMED_WAITING,

      //终止
        TERMINATED;
    }

2.wait和sleep的区别

1.来自不同的类

wait=>Object类   

sleep => Thread类

2.关于锁的释放

wait 会释放锁,

sleep 睡觉了,抱着锁睡觉,不会释放!

3.使用的范围是不同的

wait  必须在同步代码块中使用

sleep 可以在任何地方睡

4.是否可以需要捕获异常   都是中断异常

wait 需要捕获异常

sleep 也需要抛出异常

3.Lock锁(重点)

1.传统Synchronized

package com.kuang.lock;
//基本的卖票例子

/**
 * 真正的多线程开发,公司中的开发,降低耦合性
 * 线程就是一个单独的资源类,他没有任何附属的操作!
 * 1.属性 、方法
 */
public class SaleTicketDemo01 {
       public static void main(String[] args) {
           //并发:多线程操作同一个资源类,把资源类丢入线程。
           Ticket ticket = new Ticket();
           //@FunctionalInterface 函数式接口 ,jdk1.8 Lambda表达式 (参数) -> {代码}
            new Thread(()->{
                for (int i = 0; i < 60; i++) {
                     ticket.sale();
                }
            },"A").start();
            new Thread(()->{
                for (int i = 0; i < 60; i++) {
                    ticket.sale();
                }
            },"B").start();
            new Thread(()->{
                for (int i = 0; i < 60; i++) {
                    ticket.sale();
                }
            },"C").start();




       }



}

// 资源类 OOP
class Ticket{
   // 属性、方法
    private int number=50;
    //卖票的方式
    public synchronized void sale(){
        if (number>0){
            System.out.println(Thread.currentThread().getName()+":卖出第"+(number--)+"张票,还剩"+number+"张票");
        }
    }


}

回顾多线程_第1张图片

2.lock接口

回顾多线程_第2张图片

new FairSync()公平锁

new NonfairSync()非公平锁

公平锁:十分公平,可以先来后到

非公平锁:十分不公平,可以插队(默认)

3秒 和 3小时的 如果公平锁 3秒中必须等3小时之后才能执行,

但是插队的话,就是谁抢到,谁执行,而且是有锁的。

package com.kuang.lock;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class SaleTicketDemo02 {
    public static void main(String[] args) {
        //并发:多线程操作同一个资源类,把资源类丢入线程。
        Ticket2 ticket = new Ticket2();
        new Thread(()->{for (int i = 0; i < 60; i++) ticket.sale();},"A").start();
        new Thread(()->{for (int i = 0; i < 60; i++) ticket.sale();},"B").start();
        new Thread(()->{for (int i = 0; i < 60; i++) ticket.sale();},"C").start();
    }
}

// 资源类 OOP
class Ticket2 {
    // 属性、方法
    private int number = 50;

    //卖票的方式
    //lock
    Lock lock =new ReentrantLock();


    public void sale() {

        lock.lock();//加锁

        try {
            //业务代码
            if (number > 0) {
                System.out.println(Thread.currentThread().getName() + ":卖出第" + (number--) + "张票,还剩" + number + "张票");
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();//解锁
        }
    }
}

3.Synchronized 和 Lock 区别

  1. Synchronized 内置的Java关键字,Lock是个 Java接口类。
  2. Synchronized 无法判断获取所得状态,Lock 可以判断是否获取到了锁。
  3. Synchronized 会自动释放锁,Lock必须要手动释放锁!如果不释放锁,死锁!
  4. Synchronized 线程1(获得锁,阻塞),线程2(等待,傻傻的等);Lock锁就不一定会等待下去;
  5. Synchronized 可重入锁,不可以中断的,非公平;Lock锁,可重入锁,可以 判断锁,非公平(可以自己设置);
  6. Synchronized 适合锁少量的代码同步问题,Lock适合锁大量的同步代码!

提问?:锁是什么?如何判断锁的是谁!

你可能感兴趣的:(JUC,java,开发语言)