JAVA复习 Day21 多线程，线程常用方法，生命周期+MYSQL复习（另一篇文章）

m0_46511996

已于 2023-02-15 15:10:10 修改

阅读量50

点赞数

文章标签： java mysql jvm

于 2023-02-14 22:20:18 首次发布

本文链接：https://blog.csdn.net/m0_46511996/article/details/129012781

版权

17多线程（基础）

17.3线程终止

17.3.1基本介绍

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

利用循环模式，控制变量来实现线程的终止

17.4线程方法

17.4.1线程的常用方法

setName//设置线程名称，使之与参数name相同
getName//返回该线程的名称
start//使该线程开始执行，JAVA虚拟机底层调用该线程的start0方法
run//调用线程对象run方法
setPriority//更改线程的优先级
getPriority//获取线程的优先级
sleep//在指定的毫秒数内让当前正在执行的线程进行休眠
interrupt//中断线程，而不是终止

yield：线程的礼让，让出cpu，让其他线程执行，但是礼让的时间不确定，所以不一定礼让成功（静态方法）

join:线程的插队，插队的线程一旦插队成功，则肯定先执行完插入的线程所有的任务
对象.join()
Thread.yield()

17.4.2线程的注意事项和细节

start底层会创建新的线程，调用run
线程优先级的范围
sleep:线程的静态方法，使当前线程休眠
interrupt，中断线程，但并没有真正的结束线程，所以一般用于中断正在休眠线程
用户线程和守护线程
用户线程：工作线程，当线程的任务执行完或通知方式结束
守护线程：一般是为工作线程服务的，当所有的用户线程结束，守护线程自动结束
常见的守护线程：垃圾回收机制

主线程开启了一个子线程，当主线程结束的时候，子线程不会结束，因为子线程不是守护线程

public class protectexe01 {
    public static void main(String[] args) throws InterruptedException {
        MyDeamonThread myDeamonThread = new MyDeamonThread();
        myDeamonThread.setDaemon(true);
        myDeamonThread.start();
        //当希望主线程结束以后，子线程自动结束
        //只需将子线程设为守护线程即可
        for (int i=1;i<=10;i++){
            System.out.println("宝强在辛苦的工作....");
            Thread.sleep(1000);
        }
    }
}

class  MyDeamonThread extends  Thread{
    public  void  run(){
        for ( ; ; ){//五限循环
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("马和宋快乐聊天，哈哈哈");
        }
    }
}

17.5线程生命周期

线程的几种状态
NEW:尚未启动的线程处于此状态
RUNNABLE：在JAVA虚拟机中执行的线程处于此状态（Ready和Running）
BLOCKED：被阻塞等待监视器锁定的线程处于此状态
WAITING：正在等待另一个线程被执行特定动作的线程处于此状态
TIMED-WAITING：正在等待另一个线程执行动作达到指定等待时间的线程处于此状态
TERMINATED：已退出的线程处于此状态

在这里插入图片描述

public class state {
    public static void main(String[] args) throws InterruptedException {
        T1 t1 = new T1();
        System.out.println(t1.getName()+"状态"+ t1.getState());
        t1.start();

        while (Thread.State.TERMINATED!= t1.getState()){
            System.out.println(t1.getName()+"状态"+ t1.getState());
            Thread.sleep(500);
            //使用快捷键添加异常，alt+enter
        }
        System.out.println(t1.getName()+"状态"+ t1.getState());
    }
}

class  T1 extends  Thread{
    @Override
    public void run() {
        while (true){
            for (int i=0;i<10;i++){
                System.out.println("hi"+i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            break;
        }
    }
}

17.6Synchronized

线程同步（408已学完）
在多线程编程，一些敏感的数据不允许被多个线程同时访问，此时就使用同步访问技术，保证数据在任何时刻，最多有一个线程访问，以保证数据的完整性

线程同步：即当有一个线程在对内存进行操作时，其他线程都不可以对这个内存地址进行操作，知道该线程完成操作，其他线程才能对该内存地址进行操作

//同步代码块
synchronized(对象){
//得到对象的锁，才能操作同步代码块
//需要被同步代码
}

synchronized还可以放在方法声明中，表示整个方法为同步方法

public synchronized void m(String name){
//需要被同步的代码
}

public class pocjet01 {
    public static void main(String[] args) {
        T3 t1 = new T3();

        new Thread(t1).start();
        new Thread(t1).start();
        new Thread(t1).start();

    }
}
class T3 implements Runnable{
    public  static  int num=100;
    private  boolean loop=true;

    public synchronized  void  sell(){
        //同步方法，这个时候锁就是在this对象
        //也可以在代码块上写synchronized，同步代码块
        //在同一个时刻，只能有一个时刻在执行该m方法
        if (num<=0){
            System.out.println("票已售空！！");
            loop =false;
            return  ;

        }
        //休眠50毫秒
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("窗口"+Thread.currentThread().getName()+"售出一张票"+
                "剩余票数="+(--num));

    }
    @Override
    public  void run() {//同步方法
        while (loop){
            sell();
            }
        }
    }

注：锁是在对象上的

17.7互斥锁

上述代码售票的原理分析
在这里插入图片描述
1、JAVA在java语言中，引入了对象互斥锁的概念，来保证共享数据操作的完整性
2、每个对象都对应于一个可称为互斥锁的标记，这个标记用来保证在任一时刻，只能有一个线程访问该对象
3、关键字synchronized来与对象的互斥锁联系，当某个对象用synchronized修饰时，表明该对象在任一时刻只能由一个线程访问
4、同步的局限性：导致程序的执行效率要降低
5、同步方法（非静态）的锁可以是this（是加在当前对象的）,也可以是其他对象（要求是同一个对象）
6、同步方法（静态的）的锁为当前类本身

class sell implements Runnable{

    public synchronized static void m1(){
        
    }
    //此时的锁是加在类的上面
    public static void m2(){
        synchronized (sell.class){
        //将锁加在类上
            System.out.println("m2");
        }
    }
}

注意事项

同步方法如果没有使用static修饰:默认锁对象为this
如果方法使用static修饰，默认锁对象：当前类.class

17.8死锁

基本介绍
多个线程都占用了对方的锁资源，但不肯相让，导致了死锁，在编程时要避免死锁的发生
释放锁：
以下会释放锁
当前线程的同步方法、同步代码块执行结束
当前线程在同步代码块、同步方法中遇到break,return
当前线程在同步代码块、同步方法中出现了未处理的Error或Exception，导致异常结束
当前线程在同步代码块、同步方法中执行了线程对象的wait()方法，当前线程暂停，并释放锁

以下不会释放锁
线程执行同步代码块或同步方法时，程序调用Thread.sleep()、Thread.yield()方法暂停当前线程的执行，不会释放锁
线程执行同步代码块时，其他线程调用了该线程suspend()方法将该线程挂起，该线程不会释放锁