Java多线程

\(这是Sheldon\)的自学笔记

视频：尚硅谷

基本概念

程序：是为了完成特定任务，用某种语言编写的一组指令集合。即指一段静态的代码一段静态的代码，静态对象。

进程：是一个程序的一次执行过程，或是正在运行的一个程序正在运行的一个程序。是一个动态的过程：它有自身的产生，存在和消亡的过程。--生命周期

如：运行中的QQ，运行中的MP3播放器
程序是静态的，进程是动态的
进程作为资源分配的单位进程作为资源分配的单位系统在运行时会为每个进程分配不同的内存区域

线程：进程可进一步细化为线程，是一个程序内部的一条执行路径。

若一个进程同一时间并行执行多个线程，就是支持多线程的
线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器(pc)，线程切开的开销小
一个进程中的多个线程共享的内存单元/内存地址空间->它们同一栈中分配对象，可以访问相同的变量和对象。这就使得线程间通信更简洁，高效。但多个线程操作共享的系统资源可能会带来安全的隐患。

单核CPU和多核CPU的理解

单核CPU，其实是一种假的多线程，因为在一个时间单元内，也只能执行一个线程的任务。例如：虽然有多车道，但是收费站只有一个工作人员在收费，只有收了费才能通过，那么CPU就好比收费人员。如果有某人不想交钱，那么收费人员可以把他“挂起”。但是因为CPU时间特别短，因此感觉不出来。
如果是多核的话，才能更好的发挥多线程的效率。（现在的服务器都是多核的）
一个Java应用程序java.exe，其实至少有三个线程：main()主线程，gc()垃圾回收线程，异常处理线程。当然如果发生异常，会影响主线程。

并行与并发

并行：多个CPU同时执行多个任务。比如：多个人同时做不同的事。
并发：一个CPU（采用时间片）同时执行多个任务。比如：秒杀，多个人做一件事。

使用多线程的优点

提高应用程序的相应
提高计算机系统CPU的利用率
改成程序结构

何时需要多线程

程序需要同时执行两个或者多个任务
程序需要实现一些等待的任务时。
需要一些后台运行的程序时。

创建多线程的第一种方式

package com.atguigu.java;

/**
 * 多线程的创建，方式一：继承于Thread类
 * 1.创建一个继承于Thread类的子类
 * 2.重写Thread类中的run() -->将此线程执行的操作声明在run()中
 * 3.创建Thread类的子类的对象
 * 4.通过此对象调用start()
 *
 * 例子：遍历100以内的所有的偶数
 *
 */

//1.创建一个继承于Thread类的子类
class MyThread extends Thread{
    //2.重写Thread类中的run()
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if(i % 2 == 0)
                System.out.println(i);
        }
    }
}
public class ThreadTest {
    public static void main(String[] args) {
        //3.创建Thread类的子类的对象
        MyThread t1 = new MyThread();
        //4.通过此对象调用start()
        t1.start();

        for (int i = 0; i < 100; i++) {
            if(i % 2 == 0)
                System.out.println(i + "**********main()***************");
        }

    }
}

注意：

我们不能通过直接调用run()的方式启动线程

在启动一个线程不可以还让已经start()的线程去执行。会报illegalThreadStateException我们需要重新创建一个线程的对象。

练习

package com.atguigu.exer;

/**
 * 练习：创建两个分线程，其中一个线程遍历100以内的偶数，另一个遍历100以内的奇数
 */
public class ThreadDemo {
    public static void main(String[] args) {
        MyThread1 m1 = new MyThread1();
        MyThread2 m2 = new MyThread2();

        m1.start();
        m2.start();
    }
}

class MyThread1 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i <100; i++) {
            if(i % 2 == 0)
                System.out.println(Thread.currentThread().getName() + ":" + i);
        }
    }
}

class MyThread2 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i <100; i++) {
            if(i % 2 != 0)
                System.out.println(Thread.currentThread().getName() + ":" + i);
        }
    }
}

线程的常用方法

package com.atguigu.java;

/**
 * 测试Thread中的常用方法：
 * 1.start()：启动当前线程；调用当前线程的run()
 * 2.run()：通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中
 * 3.currentThread()：静态方法，返回执行当前代码的线程
 * 4.getName()：获取当前线程的名字
 * 5.SetName()：设置当前线程的名字
 * 6.yield()：释放当前CPU的执行权
 * 7.join()：在线程a中调用线程b的join()，此时线程a就进入阻塞状态，直到线程b
 * 完全执行完以后，线程a才结束阻塞状态。
 * 8.stop():当执行此方法时，强制结束当前线程。
 * 9.sleep()：让当前线程“睡眠”指定millitime毫秒数。在指定millitime毫秒时间内，当前
 * 线程是阻塞状态。
 * 10.isAlive()：判断当前线程是否存活
 */

class HelloThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if(i % 2 == 0){
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
            if(i== 0){
                this.yield();
            }

        }
    }
    public HelloThread(String name){
        super(name);
    }
}

public class ThreadMethodTest {
    public static void main(String[] args) {
        HelloThread h1 = new HelloThread("Thread:1");
//        h1.setName("线程一");

        h1.start();

        //给主线程命名
        Thread.currentThread().setName("主线程");

        for (int i = 0; i < 100; i++) {
            if(i % 2 == 0){
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
            if(i == 20) {
                try {
                    h1.join();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        }

    }
}

线程的调度

调度策略

时间片
抢占式：高优先级的线程抢占CPU

Java的调度方法

同优先级线程组成先进先出队列（先到先服务），使用时间片策略
对高优先级，使用优先调度的抢占式策略

线程的优先级等级

MAX_PRIORITY：10
MIN_PRIORITY：1
NORM_PRIORITY：5

涉及的方法

getPriority()
setPriority(int p)

/**
*线程的优先级
* 1.
* - MAX_PRIORITY：10
* - MIN_PRIORITY：1
* - NORM_PRIORITY：5 -->默认优先级
*
* 2.如何获取和设置当前线程的优先级
*      getPriority():获取线程的优先级
*      setPriority(int p):设置线程的优先级
*      说明：高优先级的线程要抢占低优先级线程cpu的执行权。但是只是从概率上讲，高优先级
*      的线程高概率情况下被执行。并不意味着只有当高优先级的线程执行完以后，低优先级的线
*      程才执行
*/

例题

package com.atguigu.java;

/**
 * 例子：创建三个窗口，总票数为100张
 */

class Window extends Thread{
    private static int ticket = 100;
    @Override
    public void run() {
        while (true){
            if(ticket > 0){
                System.out.println(getName() + ":卖票，票号为：" + ticket);
                ticket--;
            }
            else {
                break;
            }
        }
    }
}

public class WindowTest {
    public static void main(String[] args) {
        Window t1 = new Window();
        Window t2 = new Window();
        Window t3 = new Window();

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");


        t1.start();
        t2.start();
        t3.start();
    }
}

创建多线程的第二种方式

package com.atguigu.java;

/**
 * 创建多线程的方式二：实现Runnable接口
 * 1.创建一个实现了Runnable接口的类
 * 2.实现类去实现Runnable中的抽象方法：run()
 * 3.创建实现类的对象
 * 4.将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
 * 5.通过Thread类的对象调用start()
 *
 */

//1.创建一个实现了Runnable接口的类
class MThread implements Runnable{

    //2.实现类去实现Runnable中的抽象方法：run()
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if(i % 2 == 0){
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    }
}

public class ThreadTest1 {
    public static void main(String[] args) {
        //3.创建实现类的对象
        MThread mThread = new MThread();
        //4.将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
        Thread t1 = new Thread(mThread);
        t1.setName("线程1");
        //5.通过Thread类的对象调用start():①启动线程②调用当前线程的run()-->调用了Runnable类型的target
        t1.start();

        //再启动一个线程，遍历100以内的偶数
        Thread t2 = new Thread(mThread);
        t2.setName("线程2");
        t2.start();
    }
}

用创建多线程的第二种方式解决例题

package com.atguigu.java;

/**
 * 例子：创建三个窗口，总票数为100张,使用实现Runnable接口的方式
 */

class Window1 implements Runnable{
    private int ticket = 100;
    @Override
    public void run() {
        while(true){
            if(ticket > 0){
                System.out.println(Thread.currentThread().getName() + ":卖票,票号为：" + ticket);
                ticket--;
            }
            else{
                break;
            }
        }
    }
}

public class WindowTest1 {
    public static void main(String[] args) {
        //只造了一个对象
        Window w = new Window();

        //一个对象放到3个构造器中，3个线程用的同一个window
        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");


        t1.start();
        t2.start();
        t3.start();
    }
}

对比创建线程的两种方式

开发中：有限选择实现Runnable接口的方式

原因：1.实现的方式没有类的但继承性的局限性

2.实现的方式更适合来处理多个线程有共享数据的情况。

联系：两种方式均要重写run()，将线程要执行的逻辑声明在run()中

每日一考

1.谈谈你对程序、进程、线程的理解

程序：是为了完成特定任务，用某种语言编写的一组指令集合。即指一段静态的代码一段静态的代码，静态对象。

线程：进程可进一步细化为线程，是一个程序内部的一条执行路径。

线程的生命周期

JDK中用Thread.State类定义了线程的几种状态

要想实现多线程，必须在主线程中创建新的线程对象。Java语言使用Thread类及其子类的对象来表示线程，在它的一个完整的生命周期中通常要经历如下的五种状态

新建：当一个Thread类或子类的对象被声明并创建时，新生的线程对象处于新建状态
就绪：处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时它已经具备了运行的条件，只是没分配到CPU资源
运行：当就绪的线程被调度并获得CPU资源时，便进入运行状态，run()方法定义了线程的操纵和功能
阻塞：在某种特殊情况下，被认为挂起或执行输入输出操作时，让出CPU并临时中止自己的执行，进入阻塞状态
死亡：线程完成了它的全部工作或线程被提前强制性地中止或出现异常导致结束

线程的同步

问题的提出

多个线程执行的不确定性引起执行结果的不稳定
多个线程对账本的共享，会造成操作的不完整性，会破坏数据。

使用同步代码块解决继承Thread类的方式的线程安全问题

package com.atguigu.java;

import java.awt.*;

/**
 * 
 * 例子：创建三个窗口，总票数为100张
 * 使用同步代码块解决继承Thread类的方式的线程安全问题
 *
 */

class Window2 extends Thread{
    private static int ticket = 100;
    private static Object obj = new Object();
    @Override
    public void run() {
        while (true) {
            synchronized (obj) {
                //错误的方式：this代表着t1,t2,t3
                //synchronized (this)
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                if (ticket > 0) {
                    System.out.println(getName() + ":卖票，票号为：" + ticket);
                    ticket--;
                } else {
                    break;
                }
            }
        }
    }
}

public class WindowTest2 {
    public static void main(String[] args) {
        Window2 t1 = new Window2();
        Window2 t2 = new Window2();
        Window2 t3 = new Window2();

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");


        t1.start();
        t2.start();
        t3.start();
    }
}

使用实现Runnable接口的方式

package com.atguigu.java;

import java.awt.*;

/**
 * 例子：创建三个窗口，总票数为100张,使用实现Runnable接口的方式
 *
 * 1.问题：卖票过程中，出现了重票，错票-->出现了线程的安全问题
 * 2.问题出现的原因：当某个线程操作车票的途中，尚未操作完成时，其他线程参与进来，也操作
 * 车票。
 * 3.如何解决：当一个线程a在操作ticket的时候，其他线程不能参与进来。直到a操作完ticket时
 * 其他线程才可以开始操作ticket。这种情况即使线程a出现了阻塞，也不能改变。
 * 4.在java中，我们通过同步机制，来解决线程的安全问题。
 *
 * 方式一：同步代码块
 * synchronized(同步监视器){
 *     //需要被同步的代码
 * }
 * 说明：1.操作共享数据的代码，即为需要被同步的代码
 *      2.共享数据：多个数据共同操作的变量。比如：ticket就是共享数据
 *      3.同步监视器，俗称：锁。任何一个类的对象，都可以充当锁
 *          要求：多个线程必须要共用同一把锁
 *
 * 方式二：同步方法
 *
 * 5.同步的方式，解决了线程的安全问题。---好处
 *   操作同步代码时，只能有一个线程参与，其他线程等待。相当于是一个单线程的过程，效率低。
 *   --局限性
 */

class Window1 implements Runnable{
    private int ticket = 100;
//    Object obj = new Object();
    @Override
    public void run() {
        while(true) {
            synchronized (this) {//此时的this：唯一的Window1的对象
                if (ticket > 0) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    System.out.println(Thread.currentThread().getName() + ":卖票,票号为：" + ticket);
                    ticket--;
                } else {
                    break;
                }
            }
        }
    }
}

public class WindowTest1 {
    public static void main(String[] args) {
        //只造了一个对象
        Window1 w = new Window1();

        //一个对象放到3个构造器中，3个线程用的同一个window
        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");


        t1.start();
        t2.start();
        t3.start();
    }
}

posted @ 2022-09-12 14:05 Sheldon2 阅读(26) 评论(0) 收藏举报

刷新页面返回顶部

Shedlon2

Keep Learning...