学习笔记——线程

一、学习重点

 

二、学习内容

JUC并发编程包案例

import java.util.concurrent.atomic.AtomicInteger;

class Ticket2 implements Runnable {

    private static AtomicInteger count = new AtomicInteger(100);

    String name;

    public Ticket2(String name) {
        this.name = name;
    }

    @Override
    public void run() {
        while(Ticket2.count.intValue() > 0){
            System.out.println(name + "正在卖票，剩余：" + count.getAndDecrement());
            if(Ticket2.count.intValue() == 0){
                System.out.println("票已售空！！");
                break;
            }
        }
    }
}
public class Ch07 {

    public static void main(String[] args) {
        Ticket2 t1 = new Ticket2("窗口一");
        Ticket2 t2 = new Ticket2("窗口二");
        Ticket2 t3 = new Ticket2("窗口三");

        new Thread(t1).start();
        new Thread(t2).start();
        new Thread(t3).start();
    }
}

/*
    两个线程轮流打印数字，从1~100

 */

public class Test01 {
    private static class MyNumberTest{
        private static Boolean flag = true;

        //要打印的数字
        private  static int count = 0;

        public synchronized void print1(){
            for (int i = 0; i < 50; i++) {
                while (!flag){
                    try {
                        wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println(Thread.currentThread().getName() + "->" + ++count);
                flag = !flag;
                notifyAll();
            }
        }
        public synchronized void print2(){
            for (int i = 0; i < 50; i++) {
                while (flag){
                    try {
                        wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println(Thread.currentThread().getName() + "->" + ++count);
                flag = !flag;
                notifyAll();
            }
        }
    }

    public static void main(String[] args) {
        MyNumberTest myNumberTest = new MyNumberTest();
        Thread t1 = new Thread(() -> {
            myNumberTest.print1();
        });
        t1.setName("线程A");
        Thread t2 = new Thread(() -> {
            myNumberTest.print2();
        });
        t2.setName("线程B");

        t1.start();
        t2.start();
    }
}

三、笔记内容

LockSupport工具类
线程阻塞的工具类。所有的方法都是静态方法，可以让线程在任意位置阻塞
阻塞之后也有唤醒的方法。
park:停车。如果把Thread看成一辆车，park就是让车停下来
unpark：让车启动让后跑起来

这里的park和unpark其实实现了wait和notify的功能
区别
1、park不需要获取某个对象的锁(不释放锁)
2、因为中断park不会抛出InterruptedException异常，需要在park之后自行判断中断状态,然后做额外的处理。

总结：1、park和unpark可以实现wait和notify的功能，但是并不和wait和notify交叉使用
2、park和unpark不会出现死锁
3、blocker的作用可以看到阻塞对象的信息

public class Ch01 {
    public static final Object OBJ = new Object();

    public void shpw(){
        try {
            super.wait();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Runnable runnable = () -> {
            synchronized (OBJ){
            System.out.println("线程[" + Thread.currentThread().getName() + "]正在执行");
            //阻塞
            LockSupport.park("我被阻塞了");
            if (Thread.currentThread().isInterrupted()){
                System.out.println("被中断了...");
            }
            System.out.println("继续执行...");
            }
        };
        Thread thread1 = new Thread(runnable,"线程一");
        Thread thread2 = new Thread(runnable,"线程二");
        thread1.start();
        Thread.sleep(1000);
        LockSupport.getBlocker(thread1);
        thread2.start();
        Thread.sleep(3000);
        //线程中断
        thread1.interrupt();
        //把thread2唤醒
        LockSupport.park(thread2);
        thread1.join();
        thread2.join();
    }
}

Lock锁
Lock是一个接口
键盘输出打印输出 非常耗资源IO操作，这两种在开发中绝对不可以使用

public static void main(String[] args) {
        Lock lock = new Lock() {
            @Override
            public void lock() {

            }

            @Override
            public void lockInterruptibly() throws InterruptedException {

            }

            @Override
            public boolean tryLock() {
                return false;
            }

            @Override
            public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
                return false;
            }

            @Override
            public void unlock() {

            }

            @Override
            public Condition newCondition() {
                return null;
            }
        };
        //加锁
        lock.lock();
        try {
            //正常处理业务逻辑
            //输入输出的操作IO操作，操作的是物理内存
            //多线程是内存操作
            System.out.println();
        } catch (Exception e) {
            //当出现异常的解决方案
        } finally {//释放资源，关闭连接，关闭输入输出流
            //手动释放锁
            lock.unlock();
        }
    }
    public void info(){
        Lock lock = new Lock() {
            @Override
            public void lock() {

            }

            @Override
            public void lockInterruptibly() throws InterruptedException {

            }

            @Override
            public boolean tryLock() {
                return false;
            }

            @Override
            public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
                return false;
            }

            @Override
            public void unlock() {

            }

            @Override
            public Condition newCondition() {
                return null;
            }
        };
        //如果拿到了锁
        if (lock.tryLock()){
            try {
                //正常处理业务逻辑
            } catch (Exception e) {
                //当出现异常的解决方案
            } finally {//释放资源，关闭连接，关闭输入输出流
                //手动释放锁
                lock.unlock();
            }
        }else {
            //如果没有拿到锁，则直接做另外的事
        }
    }

Lock接口的实现类ReentrantLock
ReentrantLock 可重入锁
实现了Lock接口
synchronized 和 Lock 的区别：
1、Lock 是一个接口， synchronized 是一个关键字，是由底层（C）语言实现的
2、synchronized 发生异常时，会自动释放线程占用的锁不会发生死锁。
Lock 发生异常，若没有主动释放，极有可能占用资源不放，需要在finally 中手动释放
3、Lock 可以让等待锁的线程中断，使用synchronized 只会让等待的线程一直等待下去，不能响应中断
4、Lock可以提高多个线程进行读操作的效率。

class Ticket implements Runnable {
    private static final ReentrantLock lock = new ReentrantLock();

    private static Integer count = 100;

    String name;

    public Ticket(String name) {
        this.name = name;
    }

    @Override
    public void run() {
        Lock lock = new Lock() {
            @Override
            public void lock() {

            }

            @Override
            public void lockInterruptibly() throws InterruptedException {

            }

            @Override
            public boolean tryLock() {
                return false;
            }

            @Override
            public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
                return false;
            }

            @Override
            public void unlock() {

            }

            @Override
            public Condition newCondition() {
                return null;
            }
        };
        while (Ticket.count > 0) {
            lock.lock();
            try {
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                if (count > 0 ){
                    System.out.println(name + "出票一张，还剩：" + count + "张！");
                    count--;
                }
            } finally {
                lock.unlock();
            }
        }
    }
}

public class Ch03 {
    public static void main(String[] args) {
        Thread one = new Thread(new Ticket("一号窗口"));
        Thread two = new Thread(new Ticket("二号窗口"));
        Thread three = new Thread(new Ticket("三号窗口"));

        one.start();
        two.start();
        three.start();
    }
}

Lock 以下功能是 synchronized 不具备的！
Reentrant Read Write Lock:
对于一个应用而言，一般情况下读操作远远多于写的操作
如果仅仅是读操作没有写的操作数据又是线程安全，读写锁给我们提供了一种锁，读的时候可以很多线程一起读
写是独占的，当有线程在执行写的操作，其他线程既不能读，也不能写。

在某些场景下，能极大的提升效率！！！

public class Ch04 {
    private  static ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    private static int count = 1;

    public static void main(String[] args) {
        Runnable read = () -> {
            //创建了一个读锁
            ReentrantReadWriteLock.ReadLock readLock = lock.readLock();
            readLock.lock();
            try {
                Thread.sleep(2000);
                System.out.println("我在读数据" + count);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }finally {
                readLock.unlock();
            }
        };
        Runnable write = () -> {
            ReentrantReadWriteLock.WriteLock writeLock = lock.writeLock();
            writeLock.lock();
            try {
                Thread.sleep(2000);
                System.out.println("我在写数据" + count);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }finally {
                writeLock.unlock();
            }
        };
        for (int i = 0; i < 100; i++) {
            Random random = new Random();
            int flag = random.nextInt();
            if (flag > 20){
                new Thread(read,"read").start();
            }else {
                new Thread(write,"write").start();
            }
        }
    }
}

Lock锁的原理cas和aqs
synchronized 是由C语言实现的，只能作为关键字来使用
Java提供了一些并发的编程的包，底层的实现原理cas和aqs
编发编程三大特性：
1、原子性：原子操作可以是一个步骤，也可以是多个步骤，但是顺序不能乱
一不可以被切割只执行其中的一部分，将整个操作视为一个整体。
原子性不仅仅是多行代码，也可能是多条指令
2、可见性
3、有序性
synchronized lock：可以保证原子性、可见性、有序性。

CAS：compare and swap ,比较并交换。JDK11改成了 compare and set
思路：就是给一个元素赋值的时候，先看看内存里的那个值到底变没变
AQS：AbstractQueuedSynchronizer 抽象队列同步器，用来解决线程同步执行的问题。它是一个双向链表

java.util.concurrent.atomic
JUC并发编程包
1、原子类Atomic
AtomicInteger:整型原子类
AtomicLong:长整型原子类
AtomicBoolean:布尔型原子类
2、数组类型Atomic
AtomicLongArray：长整型数组原子类
AtomicIntegerArray：整型数组原子类
AtomicReference<V>:引用数据类型原子类

public class Ch06 {
    private static AtomicInteger adder = new AtomicInteger();

    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < 1000; i++) {
            Thread thread = new Thread(() -> {
                adder.getAndIncrement();
            }) ;
            thread.start();
            thread.join();
        }
        System.out.println(adder.get());
    }
}

线程池
为什么使用线程池
（1）降低资源消耗。通过重复利用已创建的线程降低创建和销毁线程造成的资源消耗
（2）提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行。
（3）提高线程的可管理性。线程比较稀缺的资源，如果无限制的创建，不仅会消耗系统资源，
还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。

JDK自带的四种线程池通过Executors提供的。
1.newCachedThreadPool：创建一个可缓存线程池，如果线程池长度超过处理需要，可以灵活回收空闲线程，
若无可回收，创建新线程。
2.newFixedThreadPool：创建一个定长的线程池，可以控制线程最大并发数，超出的线程会在队列中等待。
3.newScheduledThreadPool：创建一个定长的线程池，支持定时及周期性任务执行
4.newSingleThreadExecutor：创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证
所有的任务按照指定顺序执行

这四种线程池的初始化都调用了同一个构造器：
ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler)
参数的意义（重要）：
corePoolSize：线程池里线程的数量，核心线程池大小
maximumPoolSize：指定了线程池里的最大线程数量
keepAliveTime：当线程池线程数量大于corePoolSize，多出来的空闲线程，多长时间被销毁
unit：时间单位
workQueue：任务队列，用于存放提交但是尚未被执行的任务
threadFactory：线程工厂，用来创建线程，线程工厂就是我们new线程的
handler：拒绝策略，是将任务添加到线程池中时，线程池拒绝该任务多采取的相应的措施。

常见的工作队列
ArrayBlockingQueue：基于数组的有界阻塞队列。FIFO。
LinkedBlockingQueue：基于链表的有界阻塞队列。FIFO

线程池提供了四种拒绝策略：
AbortPolicy：直接抛出异常，默认的策略。
CallerRunPolicy：用调用者所在的线程来执行任务
DiscardOldestPolicy：丢弃阻塞队列中最靠前的任务，并执行当前任务
DiscardPolicy：直接丢弃任务

public static void main(String[] args) {
        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();

        Runnable taskOne = () -> {
            System.out.println(Thread.currentThread().getName() + "taskOne...");
        };

        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(10);

        ExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(10);

        ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();

        for (int i = 0; i < 40; i++) {
            fixedThreadPool.submit(taskOne);
        }
    }

自定义线程池

import java.util.concurrent.atomic.AtomicInteger;

/**
 * 自定义线程池
 *
 */
public class Ch02 {

    private static final AtomicInteger poolNumber = new AtomicInteger(1);

    private final ThreadGroup group;

    private final AtomicInteger threadNumber = new AtomicInteger(1);

    private final String namePrefix;

    Ch02(String name){
        SecurityManager s = System.getSecurityManager();
        group = (s != null) ? s.getThreadGroup() : Thread.currentThread().getThreadGroup();

        namePrefix = name + "-" + poolNumber.getAndIncrement() + "-thread-";
    }

    Ch02(){
        this("default");
    }

    public Thread newThread(Runnable r){
        // 就是在创建线程
        Thread t = new Thread(group,r,namePrefix + threadNumber.getAndIncrement(),0);

        if(t.isDaemon()){
            t.setDaemon(false);
        }
        if(t.getPriority() != Thread.NORM_PRIORITY){
            t.setPriority(Thread.NORM_PRIORITY);
        }
        return t;
    }

    public static void main(String[] args) {
        Ch02 ch02 = new Ch02();
        ch02.newThread(()->{
            System.out.println("自定义线程池创建的线程...");
        }).start();
    }

}

重点（需要掌握）：

1、创建线程的4种方式*****
2、线程同步(synchronized,ReentrantLock,ReentrantReadWriteLock)
3、线程之间的通信（wait，notify，notifyAll）*****
4、线程类的常用方法

指令重排，线程争抢，可见性，原子性，volatile关键字