chapter17 多线程基础

多线程

线程相关概念

进程

进程是指运行中的程序，比如我们使用QQ,就是启动了一个进程，操作系统会为该进程分配内存空间。当我们使用迅雷，又启动了一个进程，操作系统将为迅雷分配内存空间
进程是程序的一次执行过程，或是正在运行的一个程序。是动态过程：有它自身的产生，存在和消亡的过程

什么是线程

线程是由进程创建的，是进程的一个实体
一个进程可以拥有多个线程

其他相关概念

单线程：同一时刻，只允许一个线程
多线程：同一时刻，可以执行多个线程。比如：一个QQ进程，可以同时打开多个聊天窗口；一个迅雷进程，可以同时下载多个文件
并发：同一时刻，多个任务交替执行，造成一种“貌似同时”的错觉，简单的说，单核CPU实现的多任务就是并发
并行：同一时刻，多个任务同时执行。多核CPU可以实现并行。同时并行中的进程也可以并发。

线程基本使用

创建线程的两种方式

在java中线程来使用两种方法：

继承Thread类，重写run方法
实现Runnable接口，重写run方法

package com.chapter17.threaduse;

public class Thread01 {
    public static void main(String[] args) throws InterruptedException {
        //创建Cat对象，可以当作线程使用
        Cat cat = new Cat();
        //解读：
        //1. public syncchronized void start(){start0();}
        //2.srart0(),是本地方法，是JVM调用，底层是C/C++实现，真正实现多线程效果，是start0(),而不是run‘
        //private native void start0()
        cat.start();
        //说明：
        // cat.run() run方法只是一个普通方法，没有真正去启动一个线程，就会把run方法执行完毕，才向下执行
        //说明:当main线程启动一个子线程Thread-0，主线程不会阻塞，会继续执行
        //这时 主线程和子线程是交替执行
        for (int i = 0; i < 30; i++) {
            System.out.println(i);
            //主线程休眠1s  否则太快 看不出来
            Thread.sleep(1000);
    }
}
static class Cat extends Thread{
    int times = 0;
//说明： 1.当一个类继承了Thread类，该类就可以当作线程使用
    //2. 我们重写run方法，添加自己的业务代码
    //3. run Thread类，实现了Runnable接口的run方法
    @Override
    public void run() {
        //重写run方法，写上自己的业务逻辑
        while(true){
            System.out.println("hahaha"+Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (times==80){
                break; //当输出80次之后，退出while循环，也就是说，结束线程
            }
        }
    }
}}

start()方法调用start0（）方法后，该线程并不一定立马执行，只是将线程变成了可运行状态。具体什么鬼时候执行，取决于CPU，由CPU同意调度。

线程应用案例，实现Runnable接口

说明：

java是单继承的，在某些情况下一个类可能已经继承了某个父类，这是在用继承Thread类方法来创建线程显然不可能了。
java设计者们提供了另外一个方式创建线程，就是通过实现Runnable接口来创建线程

package com.chapter17.threaduse;

public class Thread02 {
    //通过实现接口Runnable来开发线程

    public static void main(String[] args) {

        Dog dog = new Dog();
        //1.创建线程对象 把实现Runnable接口的dog对象传入 放到thread中
        Thread thread = new Thread(dog);
        //2.线程thread启动
        thread.start();

        //Tirger tirger = new Tirger(); //实现了Runnable接口
        //ThreadProxy threadProxy = new ThreadProxy(tirger);
        //threadProxy.start();
    }



}
//通过实现Runnable接口，开发线程
class Dog implements Runnable{
    int count = 0;

    @Override
    public void run() {  //run只是一个普通方法，直接调用的话不会实现线程交替执行
        while(true){
            System.out.println("小狗 汪汪汪" + Thread.currentThread().getName());
            //休眠1s  需要添加异常捕获
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (count == 10){
                break;
            }
        }

    }
}

class  Animal {

}
class Tirger extends Animal implements Runnable{
    @Override
    public void run() {
        System.out.println("老虎嗷嗷叫");
    }
}
//线程代理类，模拟一个既简单的Thread类
class ThreadProxy implements Runnable{
    private Runnable target = null;
    //属性 类型是Runnable


    @Override
    public void run() {
        if (target != null){
            target.run();  //这块是动态绑定
        }
    }

    public ThreadProxy(Runnable target) {
        this.target = target;
    }
    public void start(){
        start0();
    }

    private void start0() {
        run();
    }

}

线程使用应用实例多线程执行

package com.chapter17.threaduse;

public class Thread03 {
    public static void main(String[] args) {
        T1 t1 = new T1();
        T2 t2 = new T2();
        Thread thread = new Thread(t1);
        Thread thread1 = new Thread(t2);
        thread.start();
        thread1.start();
    }
}

class T1 implements Runnable {
    int count = 0;

    @Override
    public void run() {
        while(true){
            //每隔一秒 输出hello world 输出10次
            System.out.println("hello world" + (++count));
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            if (count == 30){
                break;
            }
        }
    }
}

class T2 implements Runnable{
    int count = 0;

    @Override
    public void run() {
        while(true){
            System.out.println("hello python" + (++count));
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (count == 40){
                break;
            }

        }

    }
}

线程如何理解

主线程main 创建一个线程去计算创建另一个线程去打印

继承Thread VS 实现 Runnable的区别

从java的设计来看，通过继承Thread或者实现Runnable接口来创建线程本质上没有区别，从jdk帮助文档我们可以看到Thread类本身就实现了Runnable接口
实现Runnable接口方式更加蛇和多个线程共享一个资源的情况，并且避免了单继承的限制，建议使用Runnable
售票系统：百年城模拟三个售票窗口售票100张，分别使用继承Thread 和实现Rubbable方式，并分析有什么问题

package javabase.chapter17.ticket;

public class SellTicket {
    public static void main(String[] args) {
        //测试
//        SellTicket01 sellTicket01 = new SellTicket01();
//        SellTicket01 sellTicket011 = new SellTicket01();
//        SellTicket01 sellTicket012 = new SellTicket01();
//        sellTicket01.start();//启动售票线程
//        sellTicket011.start();
//        sellTicket012.start();
        //会出现超卖的现象


        //测试 ---也会有超卖的现象
        SellTicket02 sellTicket02 = new SellTicket02();
        SellTicket02 sellTicket03 = new SellTicket02();
        SellTicket02 sellTicket04 = new SellTicket02();
        Thread thread = new Thread(sellTicket02);
        Thread thread1 = new Thread(sellTicket03);
        Thread thread2 = new Thread(sellTicket04);

        thread.start();
        thread1.start();
        thread2.start();
    }
}

//使用Thread方式
class SellTicket01 extends Thread{
    //让多个线程共享ticketNum
    private static int ticketNum = 100;

    @Override
    public void run() {
        while (true){
            if (ticketNum < 0){
                System.out.println("搜票结束");
                break;
            }
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("窗口"+Thread.currentThread().getName()+"售一张票"+"剩余票数"+(--ticketNum));

        }
    }
}
//实现接口的方式
class SellTicket02 implements Runnable{
    private int ticketNum = 100; //让多个线程共享ticketNum

    @Override
    public void run() {
        while(true){
            if (ticketNum < 0){
                System.out.println("卖完了");
                break;
            }
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("窗口"+Thread.currentThread().getName()+"卖了一张"+"当前票数"+(--ticketNum));

        }
    }
}

线程终止

基本说明

当线程完成任务后，会自动退出
还可以通过使用变量来控制run方法退出的方式停止线程，即通知方式

应用案例

需求：启动一个线程t 要求再mnain线程中去停止线程t 编程实现

package javabase.chapter17.exit_;

public class ThreadExit_ {
    public static void main(String[] args) {

        AThread aThread = new AThread();
        new Thread(aThread).start();
        for (int i = 0; i < 50; i++) {
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (i == 40){
                aThread.setLoop(false);
            }
        }
    }
}
class AThread implements Runnable{
    boolean loop = true;

    @Override
    public void run() {
        while (loop){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("AThread运行中");
        }
    }
    public void setLoop(boolean loop){
        this.loop = loop;
    }
}

线程常用方法

第一组常用方法

setName 设置线程的名称使之与参数那么相同
getName 返回改线程的名称
start 使该线程开始执行；java虚拟机底层调用该线程的start0方法
run 调用线程对象run方法
setPriority 更改线程的优先级
getPriority 获取线程的优先级
sleep 在指定的毫秒数内让当前正在执行的线程休眠（暂停执行）
interrupt 终端线程
注意事项和细节
start底层会创建新的线程，调用run 润就是一个简单的方法调用，不会启动新县城
线程优先级范围
interrupt终端线程但并没有真正的结束线程。所以一般用于终端正在休眠线程
sleep线程的静态方法，使当前的线程休眠
应用案例

package javabase.chapter17;

public class ThreadMethod01 {
    public static void main(String[] args) {
        ThreadDemo1 threadDemo1 = new ThreadDemo1();
        threadDemo1.setName("小笼包");
        threadDemo1.setPriority(Thread.MIN_PRIORITY);
        threadDemo1.start();
        //测试优先级
        System.out.println("默认优先级 = " + Thread.currentThread().getPriority());
        //测试interrupt
//        try {
//            Thread.sleep(3000);
//        } catch (InterruptedException e) {
//            System.out.println(Thread.currentThread().getName() + "被interrupt了");
//        }
        threadDemo1.interrupt();
    }
}
class ThreadDemo1 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + "吃包子");
            try {
                System.out.println(Thread.currentThread().getName() + "休眠中");
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                //当该线程执行到一个interrupt方法时，就会catch一个异常 就可以加入我们的业务代码
                System.out.println(Thread.currentThread().getName() + "被interrupt了");
                e.printStackTrace();
            }

        }
    }
}

常用第二组方法

yied 线程的礼让让出cpu 让其他线程执行，但礼让的时间不确定，所以不一定礼让成功
join 线程的插队插队的线程一旦插队成功，则肯定限制性完插入的线程所有的任务
案例：main线程创建一个子线程，每隔1s输出hello，输出20次，主线程每隔1s，输出hi，输出20次。要求：两个线程同时执行，当主线程输出5次后，就让子线程执行完毕，主线程再继续

应用案例

测试yied和join方法注意体会方法的特点

package javabase.chapter17;

public class ThreadMethod02 {
    public static void main(String[] args) throws InterruptedException {
        //测试join的使用
        T t = new T();
        t.start();
        //说明 让子线程插队到主线程中，这样main就会等待子线程执行完毕，再执行
        // 如果没有join 那么主线程和子线程就会交替执行
        for (int i = 0; i < 20; i++) {
            if (i == 5){
                t.join();
            }
            Thread.sleep(50);
            System.out.println("主线程");
        }
    }
}
class T extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("子线程");
        }
    }
}

课堂练习

需求：主线程每隔1s 输出hi 一共10次
当输出hi到5时，启动一个子线程（要求实现Runnable）每隔1s输出hello，等该线程输出10此后，退出
主线程继续输出hi 直到主线程退出

package javabase.chapter17.method;

public class ThreadMethodExercise {
    public static void main(String[] args) throws InterruptedException {
        //创建子线程
        Thread thread = new Thread(new T3());
        for (int i = 0; i < 10; i++) {
            System.out.println("hi" + i);
            if (i == 5){
                thread.start(); //启动子线程
                thread.join(); //立即将子线程 插入main线程 先让子线程执行
            }
            Thread.sleep(1000);//没输出一次hi 主线程休眠1s
        }

    }
}
class T3 implements Runnable{
    private int count = 0;

    @Override
    public void run() {
        while (true){
            System.out.println("hello" + (++count));
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (count == 10){
                break;
            }
        }
    }
}

用户线程和守护线程

用户线程也叫做工作线程，当线程的任务执行完成或者通知方式结束
守护线程一般是为工作线程服务的，当所有的用户线程结束，守护线程自动结束
常见的守护线程：垃圾回收机制

应用案例

package com.chapter17.threadmethod;

public class ThreadMethod03 {
    public static void main(String[] args) {
        MyDeamonThread dt = new MyDeamonThread();
        //将dt设置为守护线程，当所有线程结束后，dt也就自动结束了
        //如果没有设置，那么即使main线程执行完毕，dt也不会退出
        //dt.setDaemon(true);
        dt.start();
        for (int i = 0; i < 10; i++) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("公司倒闭了");
        }
    }
}
class MyDeamonThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println("员工在工作" + i);
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

线程的生命周期

JDK中用Thread.State 枚举表示了线程的几种状态

线程可以处于一下几种状态
new 尚未启动的线程处于该状态
RUNNABLE 在java虚拟机中执行的线程处于此状态
BLOCKED 被阻塞等待监视器锁定的线程处于此状态
WAAITING 正在等待另一个线程执行特定动作的线程处于此状态
TIMED_WAITING 正在等待另一个线程执行动作达到指定等待时间的线程处于此状态
TERMTNATED 已退出的线程处于此状态

线程状态转换图

pass
自定百度

写程序查看线程状态

package com.chapter17.state_;

public class ThreadState_ {
    public static void main(String[] args) {
        T t = new T();
        System.out.println(t.getName()+"状态"+t.getState());
        t.start();
        while(Thread.State.TERMINATED!=t.getState()){
            System.out.println(t.getName()+"状态"+t.getState());
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(t.getName()+"状态"+t.getState());
        }
    }
}
class T extends Thread{
    @Override
    public void run() {
        while (true){
            for (int i = 0; i < 10; i++) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                break;
            }
        }
    }
}

线程的同步

以前做的售票窗口的问题会出现超卖的现象

Synchronized

线程同步机制

在多线程编程，一些敏感数据不允许被多个线程同时访问，此时就使用同步访问计数，保证数据在任何同一时刻，最多被一个线程访问，以保证数据的完整性
也可以这样理解：线程同步，即当有一个线程在对内存进行操作时，其他线程都不可以对这个内存地址进行操作，知道该线程完成操作，其他线程才能对该内存地址进行操作

同步具体方法 Synchronized

同步代码块
synchronized(对象){//得到对象的锁，才能操作同步代码
// 需要被同步的代码；}
synchronized还可以方法声明中，表示整个方法-为同步方法
public synchronized void m(String name){
//需要被同步的代码}
如何理解：就是上锁线程在拿到锁之后才能对数据进行操作同时其他线程无法拿到该锁，直到之前线程释放该锁】

互斥锁

基本介绍

java语言中，引入对象互斥锁的概念，来保证共享数据操作的完整性
每个对象都对应一个可称为“互斥锁”的标记，这个标记用来保证在任意时刻，只能有一个线程访问对象。
关键字synchronized来与对象的互斥锁联系。当某个对象用synchronized修饰时，表明该对象在任一时刻只能由一个线程访问
同步的局限性：导致程序的执行效率降低
同步方法（非静态的）的锁可以是this，也可以是其他对象（要求是同一对象）
同步方法（静态的）的锁为当前类本身

使用互斥锁解决售票问题

两种方式都演示代码块枷锁，方法加锁

package com.chapter17.syn;

public class SellTicket {
    public static void main(String[] args) {
        //测试下：
        //SellTicket03 sellTicket03 = new SellTicket03();
        //new Thread(sellTicket03).start();
        //new Thread(sellTicket03).start();
        //new Thread(sellTicket03).start();
        SellTicket01 sellTicket01 = new SellTicket01();
        SellTicket01 sellTicket011 = new SellTicket01();
        SellTicket01 sellTicket012 = new SellTicket01();
        sellTicket01.start();
//        sellTicket01.start();
//        sellTicket01.start();
        sellTicket011.start();
        sellTicket012.start();


    }
}
//实现接口方法，使用synchronized实现线程同步
class SellTicket03 implements Runnable{
    private int ticketNum = 100;   //让多个线程共享ticketNum
    private boolean loop = true; //控制run方法的变量
    Object object = new Object();
    //同步方法（静态的）的锁为当前类本身
    //解读
    //1.public synchronized static void m1(){}锁施加在SellTicker03.class

    public synchronized static void m1(){}
    //2. 如果在静态方法中，实现一个同步代码块
    public static void m2(){
        synchronized (SellTicket.class){
            System.out.println("m2");
        }
    }
    //解读:
    //1. public synchronized void sell(){} 就是一个同步方法
    //2. 这时 锁在this 对象
    //3. 也可以在代码块上写synchronized 同步代码块，互斥锁还是在在this对象
    public /*synchronized*/ void sell(){//同步方法，在同一时刻，只能有一个线程来执行sell防范
        synchronized (this){
            if (ticketNum <= 0){
                System.out.println("售票结束");
                loop  = false;
                return;
            }
        }
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("窗口"+Thread.currentThread().getName()+"售票一张"+"剩余票数"+(--ticketNum));
    }

    @Override
    public void run() {
        while(loop){
        sell();   //sell方法是一共同步方法
    }}
}
//使用thread方式
class SellTicket01 extends Thread{
    boolean loop = true;
    private static int ticketNum = 100;  //让多个线程共享 ticketNum
    Object object = new Object();

    @Override
    public void run() {
        while(loop){
            sell();
        }
    }
    public  void sell(){
        synchronized (object) {
            if (ticketNum <= 0) {
                System.out.println("卖完了");
                loop = false;
            }
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("窗口" + Thread.currentThread().getName() + "卖出一张；" + "当前剩余" + (--ticketNum));
        }

    }
}

注意：

同步方法如果没有使用static，默认锁对象是this
如果方法使用static修饰，默认锁对象当前类.class
实现落地步骤：

需要线分析上锁的代码
选择同步代码块或同步方法
要求多个线程的锁对象为同一个即可

线程的死锁

基本介绍

多个线程都占用了对方的资源，但不肯相让，导致了死锁，在编程时，一定要避免死锁的发生

应用案例

package com.chapter17.syn;

public class DealLock_ {
    public static void main(String[] args) {

        //模拟死锁现象
        DeadLockDemo deadLockDemo = new DeadLockDemo(true);
        deadLockDemo.setName("A");
        DeadLockDemo deadLockDemo1 = new DeadLockDemo(false);
        deadLockDemo1.setName("B");
        deadLockDemo.start();
        deadLockDemo1.start();
    }
}
class DeadLockDemo extends Thread{
    static Object o1 = new Object();  //保证多线程，共享一个对象 这里使用static
    static Object o2 = new Object();
    boolean flag;

    public DeadLockDemo(boolean flag){
        this.flag = flag;
    }

    @Override
    public void run() {
        //下面业务逻辑分析
        //1. 如果flag 为True，线程A就会先得到/持有o1对象锁，然后尝试去获取o2对象锁
        //2.如果线程A得不到o2对象所，就会BLOCKED
        //3.如果flag是false 线程B就会先得到/持有o2对象锁，然后尝试去获取o1对象锁
        //4.如果B线程得不到o1对象锁 就会Blocked
        if (flag){
            synchronized (o1){ // 对象互斥锁，限免就是同步代码
                System.out.println(Thread.currentThread().getName()+ "进入1");
                synchronized (o2){//这里获得o2对象的锁
                    System.out.println(Thread.currentThread().getName()+ "进入2");

                }
            }
        }
        else{
            synchronized (o2){
                System.out.println(Thread.currentThread().getName()+"进入2");
                synchronized (o1){
                    System.out.println(Thread.currentThread().getName()+"进入1");
                }
            }
        }
    }
}

释放锁

下面的操作会释放锁

当前线程的同步方法，同步代码块执行结束
当前线程在同步方法，同步代码块中遇到break，return。
当前线程在同步代码块/同步方法中出现未处理的Error、Exception 导致异常结束执行
当前线程在同步代码块，同步方法中主席那个了线程对象的wait（）方法，当前线程暂停，并且释放锁

下买你的操作不会释放锁

线程执行同步代码块或同步方法时，程序调用Thread.sleep(),Thread.yied()方法暂停当前线程的执行，不会释放锁
线程执行同步代码块时，其他线程调用了该线程的suspend（）方法将该线程挂起，该线程不会释放锁（不建议使用该种方法）

本章作业

pass

posted @ 2022-09-26 17:01 sakera 阅读(37) 评论(0) 收藏举报

刷新页面返回顶部

chapter17 多线程基础

多线程

线程相关概念

进程

什么是线程

其他相关概念

线程基本使用

创建线程的两种方式

线程应用案例，实现Runnable接口

线程使用应用实例 多线程执行

线程如何理解

继承Thread VS 实现 Runnable的区别

线程终止

基本说明

应用案例

线程常用方法

第一组常用方法

常用第二组方法

应用案例

课堂练习

用户线程和守护线程

应用案例

线程的生命周期

JDK中用Thread.State 枚举表示了线程的几种状态

线程状态转换图

写程序 查看线程状态

线程的同步

Synchronized

线程同步机制

同步具体方法 Synchronized

互斥锁

基本介绍

使用互斥锁解决售票问题

注意：

线程的死锁

基本介绍

应用案例

释放锁

下面的操作会释放锁

下买你的操作不会释放锁

本章作业

公告

线程使用应用实例多线程执行

写程序查看线程状态