JUC并发编程DAY01

基础知识
一.摩尔定律：CPU主频翻倍，揭示了信息技术进步的速度
二.函数式接口
1.定义：
函数式接口：有且仅有一个抽象方法的接口
抽象方法：public abstract void 方法名（）；
体现：Lambda 表达式
总结：函数式接口即可以适用于Lambda 使用 的接口
2.常用的函数式接口
Supplier接口
Consumer接口
Predicate接口
Function接口
三.并发 并行
四.进程 线程 管程
管程即锁
执行线程要求先成功持有管程，然后才能执行方法，最后当方法完成（正常异常）时释放管程。在方法执行期间，执行线程持有了管程，其他任何线程都无法再获取用一个管程。
五.用户线程 守护线程
守护线程：垃圾回收线程
六.JUC Java.util.concurrent Java并发包
wait与sleep
(1)sleep是Thread的静态方法，wait是Object的方法，任何对象实例都能调用
(2)sleep不会释放锁，也不会占用锁。wait会释放锁，但前提是当前线程占有锁（即代码要在synchronized中）
(3)他们都可以被interrupt方法中断
七.synchronized实例

//一个类中可以有多个类但只能有一个public类
class Ticket{
    private int numbers=30;
    public synchronized void  sale()
    {
        if(numbers>0)
        {
            System.out.println("当前线程"+Thread.currentThread().getName()+"卖出" + (numbers--)+"剩下票数"+numbers);
        }
    }
}
public class synchronizedSaleTickets {
    public static void main(String[] args) {
        Ticket ticket=new Ticket();

        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i <40 ; i++) {
                    ticket.sale();
                }
            }
        },"t1").start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i <40 ; i++) {
                    ticket.sale();
                }
            }
        },"t2").start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i <40 ; i++) {
                    ticket.sale();
                }
            }
        },"t3").start();
    }
}

结果


八.lock接口

import java.util.concurrent.locks.ReentrantLock;

//一个类中可以有多个类但只能有一个public类
class LockTicket{
    private int numbers=30;
    private final ReentrantLock lock=new ReentrantLock();
    public void  sale()
    {
        lock.lock();

        try {
            if(numbers>0)
            {
                System.out.println("当前线程"+Thread.currentThread().getName()+"卖出" + (numbers--)+"剩下票数"+numbers);
            }
        } finally {
            lock.unlock();
        }

    }
}
public class LockSaleTickets {
    public static void main(String[] args) {
        LockTicket ticket=new LockTicket();

        //lambda表达式
        new Thread(()->{
                for (int i = 0; i <40 ; i++) {
                    ticket.sale();
                }
        },"t1").start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i <40 ; i++) {
                    ticket.sale();
                }
            }
        },"t2").start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i <40 ; i++) {
                    ticket.sale();
                }
            }
        },"t3").start();
    }
}

九，lock与synchronized对比
1.lock可以响应中断，synchronized不可以，等待线程会一直等待
2.lock如果没有及时调用unlock（）可能会导致死锁，synchronized不会
3.平时性能差不多，如果竞争资源激烈，则lock性能更优