Java多线程学习总结（一）

青旅半醒 2023-07-06 13:14 86阅读 0赞

## Java多线程学习总结（一） ##

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

#### 1.什么是JUC？ ####

在 Java 5.0 提供了 java.util.concurrent （简称 JUC ）包，在此包中增加了在并发编程中很常用 的实用工具类，用于定义类似于线程的自定义子 系统，包括线程池、异步 IO 和轻量级任务框架。 提供可调的、灵活的线程池。还提供了设计用于 多线程上下文中的 Collection 实现等。  
![在这里插入图片描述][20200219103905524.png]  
主要是以上三个包。注：atomic是原子性的意思。

#### 2.进程和线程 ####

进程，简单地说，就是在后台运行的程序；线程，简单而言，就是在程序中执行的任务。现在，看一下比较官方的定义：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzM5NTkxMQ_size_16_color_FFFFFF_t_70]

#### 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();

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

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

[20200219103905524.png]: https://img-blog.csdnimg.cn/20200219103905524.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzM5NTkxMQ_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200219104638610.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzM5NTkxMQ==,size_16,color_FFFFFF,t_70