多线程与高并发(一)

线程的概率

1. 程序,进程,线程,纤程

程序: 比如 QQ.exe 就是一个程序
进程: 当你双击QQ.exe时,就会启动一个进程,进程可以有多个,进程相对于程序来说它是一个动态的概念
线程: 作为一个进程里面最小的执行单元它就是一个线程,用简单的话讲一个程序里不同的执行路径就是一个线程(在Linux里面线程就是一个小进程)
纤程:是在用户空间的,占用空间比线程小,可以用于高吞吐量计算的程序

2.创建线程的几种方式

1. new Thread().start
2. new Thread(Runnable).start
3. 创建一个线程池,同里面的execute方法或submit方法搭配Callable和FutureTask

3.线程里面的方法

1. sleep()
意思就是睡眠,当前线程暂停一顿时间让给别的线程去执行,不会释放锁
sleep是怎么复活?由你的睡眠时间而定,等睡眠到规定的时间自动复活
2. yield()
就是当前线程正在执行的时候停止下来进入等待队列,回到等待队列里,等操作系统的算法调用,依然有可能会把这个线程又拿回去继续执行,当然更大的可能性是把原来等待的那些拿出去一个执行,所以yield的意思就是让出一下CPU,后面你们能不能抢到那我不管
3. join()
意思就是在自己当前线程加入你调用join的线程,本线程等待.等调用的线程运行完了,自己再去执行,比如:t1和t2两个线程,t1的某个点上调用t2.join(),它会跑到t2去运行,t1等待t2运行完毕继续t1运行
4. interrupt
相关的三个方法：

    public void interrupt()            //t.interrupt() 打断t线程（设置t线程某给标志位f=true，并不是打断线程的运行）
    public boolean isInterrupted()     //t.isInterrupted() 查询打断标志位是否被设置（是不是曾经被打断过）
    public static boolean interrupted()//Thread.interrupted() 查看“当前”线程是否被打断，如果被打断，恢复标志位

1. interrupt() ：实例方法，设置线程中断标志（打扰一下，你该处理一下中断）
2. isInterrupted()：实例方法，有没有人打扰我？
3. interrupted()：静态方法，有没有人打扰我（当前线程）？复位！

sleep()方法在睡眠的时候，不到时间是没有办法叫醒的，这个时候可以用interrupt设置标志位，然后呢必须得catch InterruptedException来进行处理，决定继续睡或者是别的逻辑，（自动进行中断标志复位）

interrupt是否能中断正在竞争锁的线程

 import com.mashibing.util.SleepHelper;
    
    /**
     * interrupt与sleep() wait() join()
     */
    public class T09_Interrupt_and_sync {
    
        private static Object o = new Object();
    
        public static void main(String[] args) {
            Thread t1 = new Thread(()-> {
                synchronized (o) {
                    SleepHelper.sleepSeconds(10);
                }
            });
    
            t1.start();
    
            SleepHelper.sleepSeconds(1);
    
            Thread t2 = new Thread(()-> {
                synchronized (o) {
    
                }
                System.out.println("t2 end!");
            });
    
            t2.start();
    
            t2.interrupt();
        }
    }

interrupt()不能打断正在竞争锁的线程synchronized()

如果想打断正在竞争锁的线程，使用ReentrantLock的lockInterruptibly()

 import com.mashibing.util.SleepHelper;
    
    import java.util.concurrent.locks.ReentrantLock;
    
    /**
     * interrupt与lockInterruptibly()
     */
    public class T11_Interrupt_and_lockInterruptibly {
    
        private static ReentrantLock lock = new ReentrantLock();
    
        public static void main(String[] args) {
            Thread t1 = new Thread(()-> {
                lock.lock();
                try {
                    SleepHelper.sleepSeconds(10);
                } finally {
                    lock.unlock();
                }
                System.out.println("t1 end!");
            });
    
            t1.start();
    
            SleepHelper.sleepSeconds(1);
    
    
            Thread t2 = new Thread(()-> {
                System.out.println("t2 start!");
                try {
                    lock.lockInterruptibly();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                }
                System.out.println("t2 end!");
            });
    
            t2.start();
    
            SleepHelper.sleepSeconds(1);
            
            t2.interrupt();
    
        }
    }

优雅的结束线程

结束线程的方法：

1. 自然结束（能自然结束就尽量自然结束）
2. stop() suspend() resume()
3. volatile标志
   1. 不适合某些场景（比如还没有同步的时候，线程做了阻塞操作，没有办法循环回去）
   2. 打断时间也不是特别精确，比如一个阻塞容器，容量为5的时候结束生产者，
      但是，由于volatile同步线程标志位的时间控制不是很精确，有可能生产者还继续生产一段儿时间
4. interrupt() and isInterrupted（比较优雅）

4.线程的状态

常见线程状态有六种:
1. 新建:当我们new一个线程时,还没有调用start()方法,该线程处于新建状态
2. Runnable:线程对象调用start()方法时候,它会被线程调度器来执行,也就是交给操作系统来执行了,那么操作系统来执行的时候,这整个的状态叫Runnable,Runnable内部有两个状态
(1)Ready就绪状态:就是线程进入了cpu的等待队列里面去排队等待cpu调用运行,就是就绪状态
(2)Running运行状态:线程被操作系统调用执行,进入运行状态
调用yield时候会从Runnning状态跑到Ready状态,线程调度器选中执行的时候又从Ready状态跑到Running状态去
3. Teminated结束:线程顺利的执行完了,就会进入结束状态
4. TimeWaiting等待:按时间等待,等时间结束自己就回去了,sleep(time),wait(time),join(time),Locksupport.parkNanos()和parkUntil()这些都是关于时间等待的方法
5. Waiting等待:在运行的时候如果调用了wait(),join(),LockSupport.park()进入Waiting状态,调用notify(),notifyAll(),LockSuport.unpark就会回到Running状态
6. Blocked阻塞:在同步代码的情况下没得到锁就会阻塞状态,获取锁的时候是就绪状态

5.问题

1. 上面状态哪些是JVM管理的?哪些是操作系统管理的?
   上面这些状态全是有jvm管理的,因为jvm管理的时候也要通过操作系统,所以呢,那个是操作系统和那个是jvm他两分不开,jvm是跑在操作系统上的一个普通程序
2. 线程什么状态时候会被挂起,挂起是否也是一个状态?
   Running的时候,在一个cpu上会跑很多线程,cpu会隔一段时间执行这个线程一下,在隔一段时间执行那个线程一下,这个是cpu内部的一个调度,把这个状态线程扔出去,从Running扔回去就叫线程被挂起,cpu控制它