学习记录——进阶版06

@学习记录

开始学习Java

遵从同学的指导，从Java se开始学习

黑马的JavaSE零基础入门【线程、异步】

教学目标：
　　能够描述Java中多线程运行原理
　　能够使用继承类的方式创建多线程
　　能够使用实现接口的方式创建多线程
　　能够说出实现接口方式的好处
　　能够解释安全问题出现的原因
　　能够使用同步代码块解决线程安全问题
　　能够使用同步方法解决线程安全问题
　　能够说出线程6个状态的名称

第一章 线程

1.1 多线程原理

17-02 多线程原理-随机性打印结果

17-03 多线程原理-多线程内存图解

1.2 Thread类

17-04 Thread类的常用方法-获取线程名称的方法

package day_06Thread.demo01getName;

/*
获取线程的名称：
1.使用Thread类中的方法getName()
    String getName() 返回该线程的名称
2.可以先获取当前正在执行的线程，使用线程中的方法getName()获取线程的名称
    static Thread currentThread() 返回对当前正在执行的线程对象的引用
 */

// 定义一个Thread类的子类
public class MyThread extends Thread{
    
    
    // 重写Thread类中的run方法，设置线程任务
    @Override
    public void run() {
    
    
//        // 获取线程名称-方法一
//        String name = getName();
//        System.out.println(name);

        // 获取线程名称-方法二
        // 静态方法，可以通过类名直接调用
//        Thread thread = Thread.currentThread();
//        String name = thread.getName();
//        System.out.println(name);

        // 链式编程
        System.out.println(Thread.currentThread().getName());
    }
}

package day_06Thread.demo01getName;

/*
线程的名称：
主线程 main
新线程 Thread-0,Thread-1...
 */
public class Demo01GetName {
    
    
    public static void main(String[] args) {
    
    
        // 创建Thread类的子类对象
        MyThread myThread = new MyThread();
        // 调用start方法，开启新线程，执行run方法
        myThread.start();

        new MyThread().start();

        // 主线程没有继承Thread类，无法直接使用getName，需要先获取当前的线程，再获取线程名称
        System.out.println(Thread.currentThread().getName());
    }
}

17-05 Thread类的常用方法-设置线程名称的方法

package day_06Thread.demo02setName;

/*
设置线程的名称（了解）
1.使用Thread类中的方法setName（名字）
    void setName(String name) 改变线程的名称，使之与参数name相同
2.创建一个带参数的构造方法，参数传递线程的名称；调用父类的带参构造方法，把线程名称传递给父类，让父类Thread给子线程起一个名字
    Thread(String name) 分配新的Thread对象
 */
public class MyThread extends Thread{
    
    
    public MyThread() {
    
    

    }

    public MyThread(String name) {
    
    
        super(name); // 把线程名称传递给父类，让父类Thread给子线程起一个名字
    }

    // 重写run方法，获取线程名称
    @Override
    public void run() {
    
    
        System.out.println(Thread.currentThread().getName());
    }
}

package day_06Thread.demo02setName;

public class Demo01SetThreadName {
    
    
    public static void main(String[] args) {
    
    
        // 开启多线程
        MyThread mt = new MyThread();
        mt.setName("张三");
        mt.start();

        // 调用带参构造方法
        new MyThread("狂徒").start();
    }
}

17-06 Thread类的常用方法-sleep

package day_06Thread.demo03sleep;

/*
public static void sleep(long millis); 使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行）
毫秒数结束后，线程继续执行
 */
public class Demo01Sleep {
    
    
    public static void main(String[] args) throws InterruptedException {
    
    
        // 模拟秒表
        for (int i = 0; i < 3; i++) {
    
    
            System.out.println(i);
            // 使用Thread类的sleep方法（静态）让程序睡眠1秒
            Thread.sleep(1000);
        }
    }
}

1.3 创建线程方式二

17-07 创建多线程程序的第二种方式

package day_06Thread.demo04Runnable;

/*
创建多线程程序的第二种方式：实现Runnable接口
java.lang.Runnable
    Runnable接口应该由那些打算通过某一线程执行其实例的类来实现，类必须定义一个run的无参方法
java.lang.Thread类的构造方法
    Thread(Runnable target) 分配新的Thread对象
    Thread(Runnable target, String name) 分配新的Thread对象
实现步骤：
1.创建一个Runnable接口的实现类
2.在实现类中重写Runnable接口的run方法，设置线程任务
3.创建一个Runnable接口的实现类对象
4.创建Thread类对象，构造方法中传递Runnable接口的实现类对象
5.调用Thread类中的start方法，开启新的线程执行run方法
 */

public class Demo01Runnable {
    
    
    public static void main(String[] args) {
    
    
        // 3.创建一个Runnable接口的实现类对象
        RunnableImpl runnable = new RunnableImpl();
        // 4.创建Thread类对象，构造方法中传递Runnable接口的实现类对象
        Thread thread = new Thread(runnable);
        // 5.调用Thread类中的start方法，开启新的线程执行run方法
        thread.start();

        for (int i = 0; i < 20; i++) {
    
    
            System.out.println(Thread.currentThread().getName() + "-->" + i);
        }


    }
}

package day_06Thread.demo04Runnable;

// 1.创建一个Runnable接口的实现类
public class RunnableImpl implements Runnable{
    
    
    // 2.在实现类中重写Runnable接口的run方法，设置线程任务
    @Override
    public void run() {
    
    
        for (int i = 0; i < 20; i++) {
    
    
            System.out.println(Thread.currentThread().getName() + "-->" + i);
        }
    }
}

1.4 Thread和Runnable的区别

17-08 Thread和Runnable的区别

package day_06Thread.demo04Runnable;

/*
创建多线程程序的第二种方式：实现Runnable接口
java.lang.Runnable
    Runnable接口应该由那些打算通过某一线程执行其实例的类来实现，类必须定义一个run的无参方法
java.lang.Thread类的构造方法
    Thread(Runnable target) 分配新的Thread对象
    Thread(Runnable target, String name) 分配新的Thread对象
实现步骤：
1.创建一个Runnable接口的实现类
2.在实现类中重写Runnable接口的run方法，设置线程任务
3.创建一个Runnable接口的实现类对象
4.创建Thread类对象，构造方法中传递Runnable接口的实现类对象
5.调用Thread类中的start方法，开启新的线程执行run方法

实现Runnable接口创建多线程程序的好处：
1.避免了单继承的局限性
    一个类只能继承一个类，类继承了Thread类就不能继承其他的类
    实现了Runnable接口，还可以继承其他的类，实现其他的接口
2.增强了程序的扩展性，降低了程序的耦合性（解耦）
    实现Runnable接口的方式，把设置线程任务和开启新线程进行了分离
    实现类中，重写了run方法，用来设置线程任务
    创建Thread类对象，调用start方法，用来开启新线程
 */

public class Demo01Runnable {
    
    
    public static void main(String[] args) {
    
    
        // 3.创建一个Runnable接口的实现类对象
        RunnableImpl runnable = new RunnableImpl();
        // 4.创建Thread类对象，构造方法中传递Runnable接口的实现类对象
//        Thread thread = new Thread(runnable); // 打印线程名称
        Thread thread = new Thread(new RunnableImpl2()); // 打印HelloWorld
        // 5.调用Thread类中的start方法，开启新的线程执行run方法
        thread.start();

        for (int i = 0; i < 20; i++) {
    
    
            System.out.println(Thread.currentThread().getName() + "-->" + i);
        }


    }
}

package day_06Thread.demo04Runnable;

// 1.创建一个Runnable接口的实现类
public class RunnableImpl implements Runnable{
    
    
    // 2.在实现类中重写Runnable接口的run方法，设置线程任务
    @Override
    public void run() {
    
    
        for (int i = 0; i < 20; i++) {
    
    
            System.out.println(Thread.currentThread().getName() + "-->" + i);
        }
    }
}

package day_06Thread.demo04Runnable;

// 1.创建一个Runnable接口的实现类
public class RunnableImpl2 implements Runnable{
    
    
    // 2.在实现类中重写Runnable接口的run方法，设置线程任务
    @Override
    public void run() {
    
    
        for (int i = 0; i < 20; i++) {
    
    
            System.out.println("HelloWorld" + i);
        }
    }
}

1.5 匿名内部类方式实现线程的创建

17-09 匿名内部类方式实现线程的创建

package day_06Thread.demo05InnerClassThread;

/*
匿名内部类方式实现线程的创建

匿名：没有名字
内部类：写在其他类内部的类

匿名内部类作用:简化代码
    把子类继承父类，重写父类的方法，创建子类对象合一步完成
    把实现类实现接口，重写接口的方法，创建实现类对象合成一步完成
匿名内部类的最终产物：子类/实现类对象，而类没有名字

格式：
    new 父类/接口() {
        重复父类/接口中的方法
    }
 */
public class Demo01InnerClassThread {
    
    
    public static void main(String[] args) {
    
    
        // 线程的父类是Thread
        new Thread() {
    
    
            // 重写run方法，设置线程任务
            @Override
            public void run() {
    
    
                for (int i = 0; i < 20; i++) {
    
    
                    System.out.println(Thread.currentThread().getName()+i);
                }
            }
        }.start();

        // 线程的接口Runnable
        new Thread(new Runnable() {
    
    
            @Override
            public void run() {
    
    
                for (int i = 0; i < 20; i++) {
    
    
                    System.out.println(Thread.currentThread().getName()+i);
                }

            }
        }).start();
    }
}

第二章 线程安全

2.1 线程安全

17-10 线程安全问题的概述

17-11 线程安全问题的代码实现

package day_06Thread.demo06ThreadSafe;

/*
模拟卖票案例
创建3个线程，同时开启，对共享的票进行出售
 */
public class Demo01Ticket {
    
    
    public static void main(String[] args) {
    
    
        // 创建Runnable接口的实现类对象
        RunnableImpl runnable = new RunnableImpl();
        // 创建Thread类对象，构造方法中传递Runnable接口的实现类对象
        Thread thread1 = new Thread(runnable);
        Thread thread2= new Thread(runnable);
        Thread thread3 = new Thread(runnable);
        // 调用start方法开启多线程
        thread1.start();
        thread2.start();
        thread3.start();

    }
}

package day_06Thread.demo06ThreadSafe;

/*
实现卖票案例
 */
public class RunnableImpl implements Runnable {
    
    
    // 定义一个多线程共享的票源
    private int ticket = 100;

    // 设置线程任务：卖票
    @Override
    public void run() {
    
    
        // 使用死循环，让卖票操作重复执行
        while (true) {
    
    
            // 首先判断票是否存在
            if (ticket > 0) {
    
    
                try {
    
    
                    Thread.sleep(10);
                } catch (InterruptedException e) {
    
    
                    e.printStackTrace();
                }
                // 卖票
                System.out.println(Thread.currentThread().getName()+ " 第" + ticket + "张票");
                ticket--;
            }
        }

    }
}

17-12 线程安全问题产生的机理

2.2 线程同步

2.3 同步代码块

17-13 解决线程安全问题——同步代码块

package day_06Thread.demo07Synchronized;

/*
卖票案例出现了线程安全问题，卖出了不存在的票和重复的票

解决线程安全问题的一种方法：使用同步代码块
格式：
    synchronized(锁对象){
        可能会出现线程安全问题的代码（访问了共享数据的代码）
    }

注意：
1.同步代码中的锁对象可以使用任意的对象
2.必须保证多个线程使用的锁对象是同一个
3.锁对象的作用：把同步代码块锁住，只让一个线程在同步代码块中执行
 */
public class RunnableImpl implements Runnable {
    
    
    // 定义一个多线程共享的票源
    private int ticket = 100;

    // 创建一个锁对象
    Object obj = new Object();

    // 设置线程任务：卖票
    @Override
    public void run() {
    
    
        // 使用死循环，让卖票操作重复执行
        while (ticket > 0) {
    
    
            // 创建同步代码块
            synchronized (obj) {
    
    
                // 首先判断票是否存在
                if (ticket > 0) {
    
    
                    // 提高安全问题出现的概率，让程序睡眠
                    try {
    
    
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
    
    
                        e.printStackTrace();
                    }
                    // 卖票
                    System.out.println(Thread.currentThread().getName() + " 第" + ticket + "张票");
                    ticket--;
                }
            }

        }
    }
}

package day_06Thread.demo07Synchronized;

/*
模拟卖票案例
创建3个线程，同时开启，对共享的票进行出售
 */
public class Demo01Ticket {
    
    
    public static void main(String[] args) {
    
    
        // 创建Runnable接口的实现类对象
        RunnableImpl runnable = new RunnableImpl();
        // 创建Thread类对象，构造方法中传递Runnable接口的实现类对象
        Thread thread1 = new Thread(runnable);
        Thread thread2= new Thread(runnable);
        Thread thread3 = new Thread(runnable);
        // 调用start方法开启多线程
        thread1.start();
        thread2.start();
        thread3.start();

    }
}

17-14 同步技术原理

2.4 同步方法

17-15 解决线程安全问题——同步方法（了解即可）

package day_06Thread.demo08Synchronized;

/*
卖票案例出现了线程安全问题，卖出了不存在的票和重复的票

解决线程安全问题的一种方法：使用同步方法
使用步骤：
1.把访问了共享数据的代码抽取出来，返稿一个方法中
2.在方法上添加synchronized修饰符

格式：
修饰符 synchronized 返回值类型 方法名（参数列表）{
    可能出现线程安全问题的代码（访问了共享数据的代码）
}
 */
public class RunnableImpl implements Runnable {
    
    
    // 定义一个多线程共享的票源
    private int ticket = 100;

    // 设置线程任务：卖票
    @Override
    public void run() {
    
    
        // 使用死循环，让卖票操作重复执行
        while (ticket > 0) {
    
    
            buyTicket();
        }

    }

    // 定义一个同步方法
    // 同步方法也会把方法内部的代码锁住，只让一个线程执行
    // 同步方法的锁对象就是实现类对象 new RunnableImpl，即this
    public synchronized void buyTicket() {
    
    
        // 首先判断票是否存在
        if (ticket > 0) {
    
    
            // 提高安全问题出现的概率，让程序睡眠
            try {
    
    
                Thread.sleep(10);
            } catch (InterruptedException e) {
    
    
                e.printStackTrace();
            }
            // 卖票
            System.out.println(Thread.currentThread().getName() + " 第" + ticket + "张票");
            ticket--;

        }
    }
}

package day_06Thread.demo08Synchronized;

/*
模拟卖票案例
创建3个线程，同时开启，对共享的票进行出售
 */
public class Demo01Ticket {
    
    
    public static void main(String[] args) {
    
    
        // 创建Runnable接口的实现类对象
        RunnableImpl runnable = new RunnableImpl();
        // 创建Thread类对象，构造方法中传递Runnable接口的实现类对象
        Thread thread1 = new Thread(runnable);
        Thread thread2= new Thread(runnable);
        Thread thread3 = new Thread(runnable);
        // 调用start方法开启多线程
        thread1.start();
        thread2.start();
        thread3.start();

    }
}

17-16 静态同步方法

package day_06Thread.demo08Synchronized;

/*
卖票案例出现了线程安全问题，卖出了不存在的票和重复的票

解决线程安全问题的一种方法：使用同步方法
使用步骤：
1.把访问了共享数据的代码抽取出来，返稿一个方法中
2.在方法上添加synchronized修饰符

格式：
修饰符 synchronized 返回值类型 方法名（参数列表）{
    可能出现线程安全问题的代码（访问了共享数据的代码）
}
 */
public class RunnableImpl1 implements Runnable {
    
    
    // 定义一个多线程共享的票源
    private static int ticket = 100;

    // 设置线程任务：卖票
    @Override
    public void run() {
    
    
        // 使用死循环，让卖票操作重复执行
        while (ticket > 0) {
    
    
            buyTicketStatic();
        }

    }

    // 静态同步方法
    // 锁对象不能是this，this是创建对象之后产生的，静态方法优先于对象
    // 静态方法的锁对象是本类的class属性 --> class文件对象（反射）
    public static /*synchronized*/ void buyTicketStatic() {
    
    
        synchronized (RunnableImpl.class){
    
    
            // 首先判断票是否存在
            if (ticket > 0) {
    
    
                // 提高安全问题出现的概率，让程序睡眠
                try {
    
    
                    Thread.sleep(10);
                } catch (InterruptedException e) {
    
    
                    e.printStackTrace();
                }
                // 卖票
                System.out.println(Thread.currentThread().getName() + " 第" + ticket + "张票");
                ticket--;

            }

        }
    }
}

2.5 Lock锁

17-17 解决线程安全问题——Lock锁

package day_06Thread.demo09Lock;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/*
卖票案例出现了线程安全问题，卖出了不存在的票和重复的票

解决线程安全问题的一种方法：Lock锁
Lock接口中的方法：
    void Lock() 获取锁
    void unLock() 释放锁
实现对象 ReentrantLock implements Lock

使用步骤：
1.在成员位置创建一个ReentrantLock对象
2.在可能会出现安全问题的代码前调用Lock接口中的方法Lock获取锁
3.在可能会出现安全问题的代码后调用Lock接口中的方法unLock释放锁
 */
public class RunnableImpl implements Runnable {
    
    
    // 定义一个多线程共享的票源
    private int ticket = 100;

    // 1.在成员位置创建一个ReentrantLock对象
    Lock lock = new ReentrantLock();

    // 设置线程任务：卖票
   /* @Override
    public void run() {
        // 使用死循环，让卖票操作重复执行
        while (ticket > 0) {
            // 2.在可能会出现安全问题的代码前调用Lock接口中的方法Lock获取锁
            lock.lock();
            // 首先判断票是否存在
            if (ticket > 0) {
                // 提高安全问题出现的概率，让程序睡眠
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                // 卖票
                System.out.println(Thread.currentThread().getName()+ " 第" + ticket + "张票");
                ticket--;
            }

            // 3.在可能会出现安全问题的代码后调用Lock接口中的方法unLock释放锁
            lock.unlock();
        }

    }*/

    // 设置线程任务：卖票
    @Override
    public void run() {
    
    
        // 使用死循环，让卖票操作重复执行
        while (ticket > 0) {
    
    
            // 2.在可能会出现安全问题的代码前调用Lock接口中的方法Lock获取锁
            lock.lock();
            // 首先判断票是否存在
            if (ticket > 0) {
    
    
                // 提高安全问题出现的概率，让程序睡眠
                try {
    
    
                    Thread.sleep(10);
                    // 卖票
                    System.out.println(Thread.currentThread().getName()+ " 第" + ticket + "张票");
                    ticket--;
                } catch (InterruptedException e) {
    
    
                    e.printStackTrace();
                } finally {
    
    
                    // 3.在可能会出现安全问题的代码后调用Lock接口中的方法unLock释放锁
                    lock.unlock(); // 无论程序是否异常，都会把锁释放
                }
            }

        }

    }
}

package day_06Thread.demo09Lock;

/*
模拟卖票案例
创建3个线程，同时开启，对共享的票进行出售
 */
public class Demo01Ticket {
    
    
    public static void main(String[] args) {
    
    
        // 创建Runnable接口的实现类对象
        RunnableImpl runnable = new RunnableImpl();
        // 创建Thread类对象，构造方法中传递Runnable接口的实现类对象
        Thread thread1 = new Thread(runnable);
        Thread thread2= new Thread(runnable);
        Thread thread3 = new Thread(runnable);
        // 调用start方法开启多线程
        thread1.start();
        thread2.start();
        thread3.start();

    }
}

第三章 线程状态

3.1 线程状态概述

17-18 线程状态概述

3.2 Timed Waiting（计时等待）

3.3 BLOCKED(锁阻塞)

3.4 Waiting(无限等待)

17-19 等待唤醒案例分析

17-20 等待唤醒案例实现

package day_06Thread.demo10WaitAndNotify;

import day10.demo02.InterfaceB;

/*
等待唤醒案例：线程之间的通信
    创建一个消费者线程：告知生产者需要的种类和数量，调用wait方法，放弃cpu的执行，进入到WAITTING状态
    创建一个生产者线程：耗时5秒生产，调用notify方法，唤醒消费者

注意：
1.生产者和消费者线程必须使用同步代码块包裹起来，保证等待和唤醒只有一个在执行
2.同步使用的锁对象必须保证唯一
3.只有锁对象才能调用wait和notify方法

Object类中的方法
void wait() 在其他先册灰姑娘调用此对象的notify()或notifyAll()方法前，导致当前线程等待
void notify() 唤醒在此对象监视器上等待的单个线程，继续执行wait方法之后的代码
 */
public class Demo01WaitAndNotify {
    
    
    public static void main(String[] args) {
    
    
        // 创建锁对象，保证唯一
        Object obj = new Object();

        // 创建消费者线程
        new Thread(){
    
    
            @Override
            public void run() {
    
    
                System.out.println("告知生产者需要的种类和数量");
                // 保证等待和唤醒只有一个执行，需要使用同步技术
                synchronized (obj){
    
    
                    try {
    
    
                        obj.wait();
                    } catch (InterruptedException e) {
    
    
                        e.printStackTrace();
                    }
                    // 唤醒之后执行的代码
                    System.out.println("消费完毕");
                }
            }
        }.start();

        // 创建生产者对象
        new Thread(){
    
    
            @Override
            public void run() {
    
    
                // 耗时5秒生产
                try {
    
    
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
    
    
                    e.printStackTrace();
                }
                // 保证等待和唤醒只有一个执行，需要使用同步技术
                synchronized (obj) {
    
    
                    System.out.println("生产完成");
                    obj.notify();
                }

            }
        }.start();
    }
}

3.5 补充知识点

17-21 Object类中wait带参方法和notifyAll方法