Java多线程学习总结（一）

Java多线程学习总结（一）

从今天开始（2020.2.19），我就要进入Java多线程的学习了，可以说这是我最薄弱的环节，一是我是非科班的，未学习过操作系统；二是我自学JavaSE的时候，直接就跳过了多线程。虽然说在牛客网上刷练习题时遇到多线程的题，多多少少有去了解一些，但是不够系统。所有，接下来的几篇博客，都会是我结合Java核心技术卷一卷二的多线程和并发的内容以及尚硅谷的JUC教程系统学习多线程知识所形成的总结。

1.什么是JUC？

在 Java 5.0 提供了 java.util.concurrent （简称 JUC ）包，在此包中增加了在并发编程中很常用 的实用工具类，用于定义类似于线程的自定义子 系统，包括线程池、异步 IO 和轻量级任务框架。 提供可调的、灵活的线程池。还提供了设计用于 多线程上下文中的 Collection 实现等。

主要是以上三个包。注：atomic是原子性的意思。

2.进程和线程

进程，简单地说，就是在后台运行的程序；线程，简单而言，就是在程序中执行的任务。现在，看一下比较官方的定义：

3.并发和并行

并发简单而言就是，多个线程，同一时间点，争取同一个资源。并行是指在同一时刻，有多条指令在多个处理器上同时执行。

4.多线程编程的企业级套路

套路： 在高内聚，低耦合的前提下，线程操作资源类。
首先编写一个资源类，并提供对外调用的方法
有几个线程操作资源，就new几个Thread

package com.Zhongger.Day02;

/**
 * @Author Zhongger
 * @Description  三个售票员卖出30张票，要怎么写呢？
 * 1.在高内聚，低耦合的前提下，线程操作资源类。
 * 1.1首先编写一个资源类，并提供对外调用的方法
 * 1.2有几个线程操作资源，就new几个Thread
 * @Date 2020.2.19
 */
public class SaleTicket {
    public static void main(String[] args) {
        Ticket ticket = new Ticket();

        //多线程操作资源类
        new Thread(new Runnable() {//匿名内部类，接口是可以new的
            @Override
            public void run() {
                for (int i = 0; i < 40; i++) {
                    ticket.saleTicket();
                }
            }
        },"A").start();
        new Thread(new Runnable() {//匿名内部类，接口是可以new的
            @Override
            public void run() {
                for (int i = 0; i < 40; i++) {
                    ticket.saleTicket();
                }
            }
        },"B").start();
        new Thread(new Runnable() {//匿名内部类，接口是可以new的
            @Override
            public void run() {
                for (int i = 0; i < 40; i++) {
                    ticket.saleTicket();
                }
            }
        },"C").start();
    }
}
class Ticket{
    private int number=30;

    public synchronized void saleTicket(){
        if (number>0){
            System.out.println(Thread.currentThread().getName()+"\t卖出第："+(number--)+"\t还剩下："+number);
        }
    }

}

上述的代码使用了synchronized关键字来保证线程安全，但是这么做有一些不好之处：如果被synchronized 修饰的方法中有很多行代码，会有线程安全问题的代码仅仅是有几行，而synchronized 修饰方法会给整个方法加锁，这就使得高并发的效率下降了。所以在jdk5以后，引入了java.util.concurrent.locks.ReentrantLock类，即可重用锁。它可以替换synchronized来对代码加锁。现在来对Ticket类做修改：

class Ticket{
    private int number=30;
    private Lock lock=new ReentrantLock();//构造了一个可重用锁对象

    public  void saleTicket(){
        /* ReentrantLock的使用套路*/
        lock.lock();
        try {
            if (number>0){
                System.out.println(Thread.currentThread().getName()+"\t卖出第："+(number--)+"\t还剩下："+number);
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
        /* **********************/
        
    }

}

注意，在一个Thread类调用start()方法时，并没有立即启动一个线程，而是要等待CPU和操作系统的底层调度完成后，该线程才能被启动。

5.线程的状态

public enum State {
        /**
         * Thread state for a thread which has not yet started.
         */
        NEW,

        /**
         * Thread state for a runnable thread.  A thread in the runnable
         * state is executing in the Java virtual machine but it may
         * be waiting for other resources from the operating system
         * such as processor.
         */
        RUNNABLE,

        /**
         * Thread state for a thread blocked waiting for a monitor lock.
         * A thread in the blocked state is waiting for a monitor lock
         * to enter a synchronized block/method or
         * reenter a synchronized block/method after calling
         * {@link Object#wait() Object.wait}.
         */
        BLOCKED,

        /**
         * Thread state for a waiting thread.
         * A thread is in the waiting state due to calling one of the
         * following methods:
         * <ul>
         *   <li>{@link Object#wait() Object.wait} with no timeout</li>
         *   <li>{@link #join() Thread.join} with no timeout</li>
         *   <li>{@link LockSupport#park() LockSupport.park}</li>
         * </ul>
         *
         * <p>A thread in the waiting state is waiting for another thread to
         * perform a particular action.
         *
         * For example, a thread that has called <tt>Object.wait()</tt>
         * on an object is waiting for another thread to call
         * <tt>Object.notify()</tt> or <tt>Object.notifyAll()</tt> on
         * that object. A thread that has called <tt>Thread.join()</tt>
         * is waiting for a specified thread to terminate.
         */
        WAITING,

        /**
         * Thread state for a waiting thread with a specified waiting time.
         * A thread is in the timed waiting state due to calling one of
         * the following methods with a specified positive waiting time:
         * <ul>
         *   <li>{@link #sleep Thread.sleep}</li>
         *   <li>{@link Object#wait(long) Object.wait} with timeout</li>
         *   <li>{@link #join(long) Thread.join} with timeout</li>
         *   <li>{@link LockSupport#parkNanos LockSupport.parkNanos}</li>
         *   <li>{@link LockSupport#parkUntil LockSupport.parkUntil}</li>
         * </ul>
         */
        TIMED_WAITING,

        /**
         * Thread state for a terminated thread.
         * The thread has completed execution.
         */
        TERMINATED;
    }

New（新创建）： 当用new运算符创建一个新线程时，如new Thread()，该线程还没开始运行，这意味着它的状态还是new，当一个线程处于new状态时，程序还没开始运行线程中的代码，在线程运行之前还有一些基础工作要做。
Runnable（可运行）： 当调用start()方法时，线程处于runnable状态，在任何给定的时刻，一个可运行的线程可能正在运行也可能没有运行。
Blocked（被阻塞）和Waiting（等待）： 暂时不活动的线程，它不运行任何代码且消耗最少的资源，知道线程调度器重新激活它。调用 Object.wait()或Thread.sleep() 方法都会使线程被阻塞，那么两者有什么区别呢？Object.wait()会将对锁的控制权放开，而Thread.sleep()不会放开对锁的控控制权。
Time_Waiting（计时等待）： 时间到了就继续执行线程。
Terminated（被终止）： 因为run方法正常退出而自然死亡；因为一个没有捕获的异常终止了run方法而意外死亡。

6.将新建线程的方式改写成Lambda表达式

new Thread(new Runnable() {//匿名内部类，接口是可以new的
            @Override
            public void run() {
                for (int i = 0; i < 40; i++) {
                    ticket.saleTicket();
                }
            }
        },"A").start();
改写成：
new Thread(()->{for (int i = 0; i < 40; i++) ticket.saleTicket(); },"A").start();

这样代码就显得简洁很多了。

今天的笔记就记到这里，明天继续更新。