01-回顾多线程

本视频笔记 全手打，由b站狂神说 视频获取

1.什么是JUC

“概念 JUC就是java.util .concurrent工具包的简称。这是一个处理线程的工具包

业务：普通的线程代码 Thread

Runnable 没有返回值，效率相比与Callable 相对较低！

---

2.线程和进程

进程 qq.exe music.exe 程序的集合

一个进程往往可可以包含多个线程，至少包含一个！

java默认有几个线程？ 2个 main 、GC

线程：开了一个进程Typora，写字，自动保存（线程负责的）

对于java而言 ：Thread Runnable Callable

java真的可以开启线程嘛 开不了

//本地方法，ja底层的c++，java无法直接操作硬件
private native void start0();

并发并行

并发: 多线程操作同一个资源

• CPU一核，模拟出来多条线程，天下武功，唯快不破，快速交替

并行（多个人一起行走）

• CPU多核，多个线程可以同时执行;线程池

public class Demo02 {
    public static void main(String[] args) {
        //获取cpu的核数
        //CPU密集型，IO密集型
        System.out.println(Runtime.getRuntime().availableProcessors());
    }
}

并发编程的本质：充分利用CPU的资源

线程有几个状态?

6个

public enum State{
    //新生
    NEW,
    //运行
    RUNNABLE,
    //阻塞
    BLOCKED,
    //等待，死死的等
    WAITING,
    //超时等待
    TIMED_WATING,
    //终止
    TERMINATED;   
}

wait / sleep 区别

1、来自不同的类

wait =>> Object

sleep=>> Thread

2.关于锁的释放

wait会释放锁，sleep睡觉了，抱着锁睡觉，不会释放！

3.使用的范围是不同的

wait 必须在同步代码块中

sleep 可以在任何地方睡

4.是否需要捕获异常

wait 不需要捕获异常

sleep 需要捕获异常

---

3.Lock锁（重点）

传统的synchronizated

package test01;

/**
 * 真正的多线程开发，公司中的开发，降低耦合性
 * 线程就是一个单独的资源类，没有任何附属的操作！
 */
public class SaleTicket {
    public static void main(String[] args) {
        //并发：多线程操作同一个资源类，把资源类丢入线程
        Ticket ticket = new Ticket();
        new Thread(()->{
            for (int i = 0; i < 40; i++) {
                ticket.sale();
            }
        },"A").start();
        new Thread(()->{
            for (int i = 0; i < 40; i++) {
                ticket.sale();
            }
        },"B").start();
        new Thread(()->{
            for (int i = 0; i < 40; i++) {
                ticket.sale();
            }
        },"C").start();

    }
}
class Ticket{
    private int number =30;
    //买票的方式
    //synchronized 本质：队列 锁
    public synchronized void sale(){
        if(number>0){
            System.out.println(Thread.currentThread().getName()+"卖出了第"+(number--)+"票，剩余："+number);
        }
    }
}

lock锁

package test01;

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

/**
 * 真正的多线程开发，公司中的开发，降低耦合性
 * 线程就是一个单独的资源类，没有任何附属的操作！
 */
public class SaleTicket2 {
    public static void main(String[] args) {
        //并发：多线程操作同一个资源类，把资源类丢入线程
        Ticket2 ticket2= new Ticket2();
        new Thread(()->{
            for (int i = 0; i < 40; i++) {
                ticket2.sale();
            }
        },"A").start();
        new Thread(()->{
            for (int i = 0; i < 40; i++) {
                ticket2.sale();
            }
        },"B").start();
        new Thread(()->{
            for (int i = 0; i < 40; i++) {
                ticket2.sale();
            }
        },"C").start();

    }
}
//lock三部曲
//1.new ReentrantLock
//2.lock.lock();//加锁
//3.lock.unlock();//解锁
class Ticket2{
    private int number =30;
   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();//解锁
        }
    }
}

synchronizated 和lock区别

公平锁 ：十分公平 先来后到
非公平锁：十分不公平，可以插队（默认）

Synchronized内置的lava关键字，Lock 是一个java类

Synchronized无法判断获取锁的状态，Lock可以判断是否获取到了锁

Synchronized会自动释放锁,lock 必须要手动释放谈!知果不释放锁，死锁

Synchronized线程1（获得锁，阻塞)、线程2(等待，傻傻的等） ; Lock锁就不一定会等待下去;  lock.tryLock()

Synchronized 可重入锁，不可以中断的，非公平; Lock，可重入锁,可以判断锁，非公平(可以自己设置);

6.Synchronized适合锁少量的代码同步问题，Lock适合锁大量的同步代码!

锁是什么，如何判断锁的是谁