Java学习笔记（八）

最新推荐文章于 2024-05-13 21:50:21 发布

掉发阿龙

最新推荐文章于 2024-05-13 21:50:21 发布

阅读量115

点赞数 1

分类专栏： Java基础

本文链接：https://blog.csdn.net/qq_45184360/article/details/115699665

版权

Java基础专栏收录该内容

13 篇文章 0 订阅

订阅专栏

本文详细介绍了Java中的线程概念，包括主线程、单线程程序及多线程的创建方式，如继承Thread类和实现Runnable接口。讲解了线程的执行流程，线程安全问题及解决方案，如同步机制、锁机制。此外，还涉及线程状态、等待唤醒机制以及线程池的使用，强调了线程池在资源管理和响应速度上的优势。

摘要由CSDN通过智能技术生成

Java学习笔记（八）

线程

主线程

主线程：执行主（main）方法的线程
单线程程序：Java程序中只有一个线程
执行从main方法开始从，从上到下依次执行

public class Person {

    private String name;

    public void run(){
        for (int i = 0; i < 20; i++) {
            System.out.println(name +","+ i);
        }
    }

    public Person() {
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

public class Demo {
    public static void main(String[] args) {
        Person p1 = new Person("小强");
        p1.run();
		//System.out.println(0/0);
        //Exception in thread "main" java.lang.ArithmeticException: / by zero
        //单线程出问题会影响下面代码的运行
        Person p2 = new Person("旺财");
        p2.run();
    }
}

在这里插入图片描述

创建线程类的第一种方式

Java使用java.lang.Thread类代表线程，所有的线程对象都必须是Thread类或者其子类的实例。每个线程的作用是完成一定的任务。实际上就是执行一段程序流即一段顺序执行的代码。Java使用线程执行体来表示这段程序流
Java中通过继承Thread类来创建并启动多线程的步骤如下：
- 定义Thread类的子类，并重写该类的run()方法,该方法的方法体就代表了线程需要完成的任务，因此把run()方法称为线程执行体
- 创建Thread子类的实例，即创建了线程对象
- 调用线程对象的start()方法来启动线程

//1、创建一个Thread子类
public class MyThread extends Thread {
    //2、在Thread类的子类中重写Thread类的run方法，设置线程任务
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println("run:" + i);
        }
    }
}

/*
* 创建多线程的第一种方式：创建Thread类的子类
* java.lang.Thread类：是描述线程的类，实现多线程就必须继承Thread类
*
* 实现步骤：
* 1、创建一个Thread子类
* 2、在Thread类的子类中重写Thread类的run方法，设置线程任务
* 3、创建Thread类的子类对象
* 4、调用Thread类中的方法start方法，开启新的线程，执行run方法
* void start() 使该线程开始执行；JVM调用该线程的run方法
* 结果是两个线程并发执行；当前线程（main线程）和另一个线程（创建的新线程，执行其run方法）
* 多次启动一个线程是非法的，特别是当前已经执行结束后，不能在重新启动
* Java程序属于抢占式调度，那个线程的优先级高，那个线程优先执行；同一个优先级，选择一个执行
* */
public class Demo{
    public static void main(String[] args) {
        //3、创建Thread类的子类对象
        MyThread myThread = new MyThread();
        //4、调用Thread类中的方法start方法，开启新的线程，执行run方法
        myThread.start();

        for (int i = 0; i < 20; i++) {
            System.out.println("main:" + i);
        }
    }

}

多线程随机打印结果的原理

在这里插入图片描述

多线程内存图解

在这里插入图片描述

Thread类的常用方法

构造方法：

public Thread()：分配一个新的线程对象
public Thread(String name)：分配一个指定名字的新的线程对象
public Thread(Runnable target)：分配一个带有指定目标的新线程对象
public Thread(Runnable target,String name)：分配一个带有指定目标的新线程并指定名字

常用方法：

public String getName()：获取当前线程的名字
public void start()：使线程开始执行；Java虚拟机嗲偶哦那个此线程的run方法
public void run()：此线程要执行的任务在此处定义代码
public static void sleep(long millis)：使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行）
public static Thread currentThread()：返回对当前正在执行的线程对象的引用

//1、创建一个Thread子类
public class MyThread extends Thread {

    public MyThread(){

    }
    //分配一个指定名字的新的线程对象
    public MyThread(String name){
        super(name);
    }
    //2、在Thread类的子类中重写Thread类的run方法，设置线程任务
    @Override
    public void run() {
        //System.out.println(getName());
        System.out.println(Thread.currentThread().getName());//Thread-0
    }
}

public class Demo{
    public static void main(String[] args) {
        //3、创建Thread类的子类对象
        MyThread myThread = new MyThread();
        //带参数的构造方法创建线程对象并指定线程名字
        //MyThread myThread1 = new MyThread("线程01");
        //4、调用Thread类中的方法start方法，开启新的线程，执行run方法
        //myThread.setName("线程01");//给线程设置名字

        myThread.start();

        System.out.println(Thread.currentThread().getName());//main

        //模拟秒表
        for (int i = 1; i <= 60; i++) {
            System.out.println(i);
            //使用Thread类的sleep方法让程序睡眠1秒
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

创建线程类的第二种方式

采用java.lang.Runnable也是常见创建线程类的方法
步骤如下：
- 定义Runnable接口的是实现类，并重写该接口的run()方法，方法的方法体是该线程的执行体
- 创建Runnable接口的实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象
- 调用线程对象的start()方法启动线程

//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);
        }
    }
}

/*
* 创建线程程序的第二种方式：实现Runnable接口
* java.lang.Runnable
*   Runnable接口应该由那些打算通过某一线程执行其实例的类来实现，类必须定义一个称为run的无参方法
* java.lang.Thread类的构造方法
*   Thread(Runnable target)分配一个带有指定目标的新线程对象
*   Thread(Runnable target,String name)分配一个带有指定目标的新线程并指定名字
* 实现步骤：
*   1、创建一个Runnable接口的实现类
*   2、在实现类中重写Runnable接口的run方法，设置线程任务
*   3、创建Thread类对象，构造方法中传递Runnable接口的实现类对象
*   4、调用Thread类中的start方法，开启新的线程执行run方法
* */
public class Demo{
    public static void main(String[] args) {
        RunnableImpl runnable = new RunnableImpl();
        //3、创建Thread类对象，构造方法中传递Runnable接口的实现类对象
        Thread thread = new Thread(runnable);
        //4、调用Thread类中的start方法，开启新的线程执行run方法
        thread.start();
    }
}

Thread和Runnable的区别

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

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

/*
* 匿名内部类方式实现线程的创建
* 匿名：没有名字
* 内部类：写在其他类内部的类
* 匿名内部类作用：简化代码
*   把子类继承父类，重写父类的方法，创建子类对象合成一步完成
*   把实现类实现接口，重写接口中的方法，创建实现类对象合成一步完成
* 匿名内部类的最终产物：子类/实现类对象，而这个对象没有名字
*
* 格式：
*   new 父类/接口(){
*       重写父类/接口中的方法
*   };
* */
public class Demo{
    public static void main(String[] args) {
        //线程的父类是Thread
        new Thread(){
            @Override
            public void run() {
                for (int i = 0; i < 20; i++) {
                    System.out.println(Thread.currentThread().getName() + "--->" + i);
                }
            }
        }.start();
        //线程的接口Runnable
        Runnable r = new Runnable(){
            @Override
            public void run() {
                for (int i = 0; i < 20; i++) {
                    System.out.println(Thread.currentThread().getName() + "--->" + i);
                }
            }
        };
        new Thread(r).start();
        //简化接口的形式
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 20; i++) {
                    System.out.println(Thread.currentThread().getName() + "--->" + i);
                }
            }
        }).start();
    }
}

线程安全

在这里插入图片描述

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--;
            }
        }
    }
}

public class Demo{
    public static void main(String[] args) {
        RunnableImpl runnable = new RunnableImpl();
        Thread t0 = new Thread(runnable);
        Thread t1 = new Thread(runnable);
        Thread t2 = new Thread(runnable);
        t0.start();
        t1.start();
        t2.start();
    }
}

线程安全问题产生的原理

在这里插入图片描述

线程同步

当我们使用多个线程访问同一资源的时候，且多个线程中对资源有写的操作，就容易出现线程安全问题
要解决上述多线程并发访问一个资源的安全性问题：也就是解决重复票与不存在票问题，Java中提供了同步机制（synchronized）来解决
窗口1线程进入操作的时候，窗口2和窗口3线程只能在外等着，窗口1操作结束，窗口1和窗口2和窗口3才有机会进入代码去执行，也就是说在某个线程修改共享资源的时候，其他线程不能修改资源，等待修改完毕同步之后，才能去抢夺CPU资源，完成对应的操作，保证了数据的同步性，解决了线程不安全的现象
有三种方式完成同步操作：
- 同步代码块
- 同步方法
- 锁机制

同步代码块

同步代码块：synchronized关键字可以用于方法中的某个区块中，表示只这个区块的资源实行互斥访问
格式：
- ```
synchronized(同步锁){
    //需要同步操作的代码
}
```
- 同步锁：
  - 对象的同步只是一个概念，可以想象为在对象上标记了一个锁
    - 锁对象：可以是任意类型
    - 多个线程对象，要使用同一把锁
    - 在任何时候，最多允许一个线程拥有同步锁，谁拿到锁就能进入代码块，其他的线程只能在外等着(BLOCKED)

public class RunnableImpl implements Runnable {

    private int ticket = 100;

    Object obj = new Object();

    @Override
    public void run() {
        while (true){
           synchronized (obj){
               if (ticket > 0){
                   try {
                       Thread.sleep(10);
                   } catch (InterruptedException e) {
                       e.printStackTrace();
                   }
                   System.out.println(Thread.currentThread().getName() + "--->正在买" + ticket + "张票");
                   ticket--;
               }
           }
        }
    }
}

同步技术的原理

在这里插入图片描述

同步方法

同步方法：使用synchronized修饰的方法，就叫做同步方法，保证线程执行该方法的时候，其它线程只能等待
格式：
- ```
修饰符 synchronized 返回值类型 方法名(参数列表){
    //可能会产生线程安全问题的代码
}
```
- 同步锁是谁：
  - 对于非static方法，同步锁就是this
  - 对于static方法，我们使用当前方法所在的类的字节码对象（类名.class）

public class RunnableImpl implements Runnable {

    private int ticket = 100;

    @Override
    public void run() {
        while (true){
           payTicket();
        }
    }
    public synchronized void payTicket(){
        if (ticket > 0){
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "--->正在买" + ticket + "张票");
            ticket--;
        }
    }
}

Lock锁

java.util.concurrent.locks.Lock机制提供了比synchronized代码块和synchronized方法更广泛的锁操作，同步代码块和同步方法具有的功能Lock都有，除此之外更强大，跟体现面向对象
java.util.concurrent.locks.ReentrantLock implements Lock
Lock锁也称同步锁，接口中加锁与释放锁的方法如下:
- public void lock()：加同步锁
- public void unlock()：释放同步锁

public class RunnableImpl implements Runnable {

    private int ticket = 100;

    Lock lock = new ReentrantLock();

    @Override
    public void run() {
        while (true){
            lock.lock();
            if (ticket > 0){
                try {
                    Thread.sleep(10);
                    System.out.println(Thread.currentThread().getName() + "--->正在买" + ticket + "张票");
                    ticket--;
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    lock.unlock();
                }
            }
        }
    }
}

线程状态

当线程被创建并启动以后，它既不是一启动就进入执行状态，也不是一直处于执行执行状态，在API中java.lang.Thread.State这个枚举中给出了六种线程的生命周期状态

线程状态	导致状态发生的条件
NEW（新建）	线程刚被创建，但并未启动，还没待用start方法
Runnable（可运行）	线程可以在Java虚拟机中运行的状态，可能正在运行自己的代码，也可能没有，这取决于操作系统处理器
Blocked（锁阻塞）	当一个线程试图获取一个对象锁，而该对象锁被其他的线程持有，则该线程进入Blocked状态，当该线程持有锁时，该线程将变成Runnable状态
Watiting（无限等待）	一个线程在等待另一个线程执行一个（唤醒）动作时，该线程进入Watiting状态，进入这个状态后不能自动唤醒，必须等待另一个线程调用`notify`或者`notifyAll`方法才能够唤醒
Timed Watiting（计时等待）	同Watiting状态，有几个方法有超时参数，调用他们将进入Timed Watiting状态，这个状态将一直保持到超时期满或者接收到唤醒通知，带有超时参数的常用方法有`Thread.sleep`、`Object.wait`
Teminated（被终止）	因为run方法正常退出而死亡，或者因为没有捕获的异常终止了run方法而死亡

在这里插入图片描述

等待唤醒

等待唤醒：线程之间的通信
- 创建一个顾客线程（消费者）：告知生产者需求，调用wait方法，放弃CPU的执行权，进入到Watiting（无限等待）
- 创建一个老板线程（生产者）：完成消费者的需求，调用notify方法，唤醒消费者
注意：
- 消费者和生产者线程必须使用同步代码块包裹起来，保证等待和唤醒只能有一个在执行
- 同步使用的锁对象必须保证唯一
- 只有锁对象才能调用wait和notify方法
Objcet类中的方法
- void wait()：在其他线程调用此对象的notify()方法或notify()方法前，导致当前线程等待
- void notify()：唤醒在此对象监视器上等待的单个线程，唤醒之后会继续执行wait之后的代码

public class Demo {
    public static void main(String[] args) {
        //创建锁对象
        Object obj = new Object();
        //创建消费者线程
        new Thread(){
            @Override
            public void run() {
                while (true){
                    //保证等待和唤醒的线程只有一个执行，需要使用同步技术
                    synchronized (obj){
                        System.out.println("消费者提出需求");
                        //调用wait方法，放弃CPU的执行权，进入等待状态
                        try {
                            obj.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        //唤醒线程之后执行的代码
                        System.out.println("消费者需求被解决");
                    }
                }
            }
        }.start();
        //创建一个生成者线程
        new Thread(){
            @Override
            public void run() {
               while (true){
                   //花5秒解决消费者的需求
                   try {
                       Thread.sleep(5000);
                   } catch (InterruptedException e) {
                       e.printStackTrace();
                   }
                   //保证等待和唤醒的线程只有一个执行，需要使用同步技术
                   synchronized (obj){
                       System.out.println("消费者的需求完成，生产者通知消费者");
                       obj.notify();
                   }
               }
            }
        }.start();
    }
}

Object类中wait带参方法和notifyAll方法

进入到TimeWaitting（计时等待）有两种方式
- 使用sleep(long m)方法，在毫秒值结束后，线程睡醒进入到Runnable/Blocked状态
- 使用wait(long m)方法，wait方法如果在毫秒值结束后，还没有被notify唤醒，就会自动醒来，线程睡醒进入到Runnable/Blocked状态
唤醒的方法：
- void notify()：唤醒在此对象监视器上等待的单个线程
- void notifyAll()：唤醒在此对象监视器上等待的所有线程

等待唤醒机制

线程间通信

概念：多个线程在处理同一个资源，但是处理的动作（线程的任务）却不相同
为什么要处理线程间通信：
- 多个线程并发执行时，在默认状态下CPU是随机切换线程的，当我们需要多个线程来共同完成一件任务，并且我们希望他们有规律的执行，那么多线程之间需要一些协调通信，以此来帮助我们达到多线程共同操作一份数据
如何保证线程间通信有效利用资源
- 多个线程在争夺同一个资源，并且任务不同时，需要线程通信来帮助解决线程之间对同一个变量的使用或操作。就是多个线程在操作同一份数据时，避免对同一共享变量的争夺。也就是我们需要通过一定的手段使各个线程能有效的利用资源，而这种手段是等待唤醒机制

等待唤醒机制

什么是等待唤醒机制
- 这是多个线程间的一种协作机制，谈到线程我们经常想到的是线程间的竞争（race），比如去争夺锁，线程间也会有协作机制
- 就是在一个线程进行规定操作后，就进入等待状态（wait()），等待其他线程执行完它们指定的代码之后再将其唤醒（notify()），在多个线程进行等待时，如果需要，可以使用notifyAll()来唤醒所有的等待线程
- wait/notify就是线程间的一种协作机制
调用wait和notify方法需要注意的细节
- wait方法与notify方法必须要由同一个锁对象调用，因为对应的锁对象可以通过notify唤醒使用同一个锁对象调用的wait方法后的线程
- wait方法和notify方法时属于Objcet类的方法的，因为锁对象可以时任意对象，而任意对象的所属类都属继承了Object类的
- wait方法和notify方法必须要在同步代码块或者同步函数中使用，因为必须要通过锁对象调用这两个方法

线程池

我们使用线程的时候就去创建一个线程，这样实现起来非常方便但是存在问题
如果并发的线程数量很多，并且每个线程都是执行了一个时间很短的任务就结束了，这样频繁创建线程就会大大降低系统的效率，因为频繁创建线程和销毁线程需要时间
而线程池可以使线程可以复用，就是执行完一个任务，并不被销毁，而是可以继续执行其他任务

线程池概念和好处

线程池：其实就是一个容纳多个线程的容器，其中的线程可以反复使用，省去了频繁创建线程对象的操作，无需反复创建而消耗过多资源
合理利用线程池能带来三个好处：
- 降低资源消耗：减少了创建和销毁线程的次数，每个工作线程都可以被返回利用，可执行多个任务
- 提高响应速度：当任务到达时，任务可以不需要等到线程创建就能立即执行
- 提高线程的可管理性：可以根据系统的承受能力，调整线程池中的工作线程的数目，防止因为消耗过多的内存

线程池的使用

线程池：JDK1.5之后提供的
java.util.concurrent.Executors:线程池的工厂，用来生产线程池
- Executors类中的静态方法：
  - static ExecutorService newFixedThreadPool(int nThread)创建一个可重用固定线程数的线程池
    - 参数：int nThread：创建线程池中包含的线程数量
    - 返回值：ExecutorService接口，返回的是ExecutorService接口的实现类对象，我们可以使用ExecutorService接口接收（面向接口编程）
  - java.util.concurrent.ExecutorService:线程池接口
    - 用来从线程池中获取线程，调用start方法，执行线程任务
      - submit(Runnable task) 提交一个Runnable任务用于执行
    - 关闭/销毁线程池的方法
      - void shutdown()
- 线程池的使用步骤：
  - 使用线程池的工厂类Executors里边提供的静态方法newFixedThreadPool生产一个指定线程数量的线程池
  - 创建一个类，实现Runnable接口，重写run方法，设置线程任务
  - 调用ExecutorService中的方法submit，传递线程任务（实现类），开启线程，执行run方法
  - 调用ExecutorService中的方法shutdown销毁线程池（不建议执行）

//2、创建一个类，实现Runnable接口，重写run方法，设置线程任务
public class RunnableImpl implements Runnable {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "创建了线程");
    }
}

public class Demo {
    public static void main(String[] args) {
        // 1、使用线程池的工厂类Executors里边提供的静态方法newFixedThreadPool生产一个指定线程数量的线程池
        ExecutorService es = Executors.newFixedThreadPool(2);
        //3、调用ExecutorService中的方法submit，传递线程任务（实现类），开启线程，执行run方法
        es.submit(new RunnableImpl());//pool-1-thread-1创建了线程
        es.submit(new RunnableImpl());//pool-1-thread-2创建了线程
        es.submit(new RunnableImpl());//pool-1-thread-1创建了线程
        //4、调用ExecutorService中的方法shutdown销毁线程池（不建议执行）
        //es.shutdown();
    }
}