java多线程基础（学习知识和心得）

轻舟慢行.

已于 2023-12-11 16:33:38 修改

阅读量75

点赞数 5

文章标签： java 开发语言

于 2023-12-10 16:19:07 首次发布

本文链接：https://blog.csdn.net/weixin_62513677/article/details/134847895

版权

本文介绍了Java中的线程基础，包括进程与线程的区别，线程的创建方法（继承Thread类和实现Runnable接口），线程的生命周期状态，线程同步（同步代码块和互斥锁），以及用户线程与守护线程的概念。还讨论了线程的终止和死锁现象及其解决方案。

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

前言

本文章是我学习韩顺平老师java零基础中线程部分的学习心得和笔记知识，希望对大家有所帮助，同时推荐各位小伙伴在链接: 哔哩哔哩韩顺平老师中进行学习

java线程

进程：运行中的一个程序，运行一个程序就相当于启动了一个进程，操作系统会为进程分配内存空间
线程：线程是由进程创建的，是进程的一个实体，一个进程可以创建多个线程
单线程：同一时刻，只允许执行一个线程
多线程：同一时刻，可以执行多个线程
并发：同意时刻多个进程交替进行执行，单核CPU实现任务
并行：同一时刻，多个任务同时进行，多核CPU可以实现并行

在java中可以获取进程信息


        Runtime runtime=Runtime.getRuntime();
        //可获取的处理器availableProcessors
        int i=runtime.availableProcessors();
        System.out.println("当前CPU数量"+i);

在java中线程的使用有两种方法

第一种：继承Thread类，重写Run方法
第二种：实现Runnable接口，重写Run方法

第一种：继承Thread

    public static void main(String[] args) {
        A a = new A();  //线程类创建的对象可以当作线程使用
        a.start();  //在启动线程的时候，会自动调用Run方法
    }
}
class A extends Thread{
    //重写Run方法实现自己的业务逻辑
    @Override
    public void run() {···}

//Thread.currentThread().getName() 方法是返回当前线程名称

在运行该Java代码时显示创建了一个进程，调用start方法之后在该进程中创建了一个线程

当main线程启动一个子线程，主线程不会阻塞，会继续执行，两个线程会交替进行

注意：真正创建一个新的线程的不是run方法，这只是一个普通方法，而调用start方法才会创建一个新的新的线程，并调用run方法

start方法真正意识上也没有实现多线程，调用start方法的时候会调用他方法中的start（0）方法，是本地方法，是JVM调用，底层由C/C++实现，真正实现多线程的效果

第二种：实现Runnable接口

public class cpuname2 {
    public static void main(String[] args) {
        Dog dog=new Dog();
        Thread thread=new Thread(dog);
        thread.start();
    }
}
class Dog implements Runnable{
    int count=0;
    @Override
    public void run() {//通过实现接口来实现线程
        while(true){
            System.out.println("小狗汪汪叫"+(++count)+Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

这段代码底层是代理模式，Thread充当代理机制，当将实现Runnable接口的类A传入Thread中，就会赋予Thread中的Runnable对象，Thread中的run方法就会调用A类中的run方法，就相当于在Tread中实现A的功能

实现Runnable接口方式更加适合多个线程共享一个资源的情况，并且避免了单继承的限制

线程终止

通过线程通知其他线程终止

其他线程中有关于线程中的控制变量通过线程改变其他线程的控制变量来终止其他线程

public void run() {
        while(www)
        {
            if(number<=0)
            {
                System.out.println("票已经卖光");
                break;
            }
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("窗口"+Thread.currentThread().getName()+"售出一张票"+"剩余票数为"+(--number));
        }
    }

线程Run方法的业务由布尔型变量控制，当改变为false时，该线程终止

 public static void main(String[] args) throws InterruptedException {
        System.out.println("主线程先休息十秒");
        tikenumber a=new tikenumber();
        a.start();
        Thread.sleep(10000);
        a.setWww(false);
    }

在其他线程同通过改变控制业务的控制变量来通知终止线程

线程的常用方法

    public static void main(String[] args) throws InterruptedException {
        System.out.println("主线程先休息十秒");
        tikenumber a=new tikenumber();
        a.setName("老韩");
        a.setPriority(Thread.MIN_PRIORITY);
        a.start();
        for (int i=0;i<5;i++)
        {
            Thread.sleep(1000);
            System.out.println("h1"+i);
        }
        System.out.println(a.getName()+"的优先级是"+a.getPriority());
        a.interrupt(); 
    }
}

setName()：设置线程的名称
setPriority()：设置线程的优先级，Thread类中带有自带优先级常量
start():启动线程
sleep()：使当前线程进入休眠
getName():得到当前线程的名称
getPrioity():得到现在线程的优先级
interrrupt()：中断线程，可用于中断线程当前的休眠，在编写线程休眠的时候会抛出终端异常

 try {
                Thread.sleep(50000);
            } catch (InterruptedException e) {
                System.out.println("休眠被打断");
            }

在休眠被中断后会执行catch中的业务操作

yield：线程的礼让，让出cpu，让其他线程执行，但礼让的时间不确定，决定权在cpu操作系统，礼让不一定成功，在cpu资源紧张的情况下，礼让成功的可能性大，使用时调用的时Thread类的yield方法
join：线程的插队，插队的线程插入成功，则肯定先执行插入的线程所有的任务

假如在线程A中执行了B线程的插队操作，这时不再执行A中的任务，而是执行线程B中的任务，当B中的所有任务完成时，才会继续完成线程A的任务

示例：当主线程输出20次hi，子线程输出20次hello，都间隔1秒，当主线程输出到第5次的时候让子线程全部输出完，主线程再执行操作

public class chadui {
    public static void main(String[] args) throws InterruptedException {
        cha s=new cha();
        s.start(); //这时两个线程同时在进行
        for(int i=0;i<20;)
        {
            System.out.println("h1 "+(++i));
            Thread.sleep(1000);
            if(i==5)
            {
                s.join();   //主线程暂停，线程s插队执行
            }
        }
    }
}
class cha extends Thread{
    int number=0;
    @Override
    public void run() {
        while(true)
        {
            System.out.println("hello "+(++number));
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            if(number==20)
            {
                break;
            }
        }
    }
}

用户线程与守护线程

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

设置守护线程

 //如果希望当主线程结束后子线程自动结束，需要将子线程设置成守护线程
        a.start();
        a.setDaemon(true);

线程的生命周期

线程的状态

名称	含义
NEW	刚刚创建的线程，尚未启动
RUNNABLE	在java虚拟机中执行的线程，正在运行的
BLOCKED	被阻塞等待监视器锁定的线程处于此状态
WAITING	正在等待另一个线程执行特定动作的线程处于此状态
TIMED_WAITING	正等待另一个线程执行动作达到指定等待时间的线程处于此状态
TERMINATED	已退出的线程处于此状态

其中Runnable中可以细化分为就绪和运行状态，原因是：整体执行状态并不是真的执行，真正是否执行是由内核的线程调度器来决定，所以要细分为就绪和执行状态

当调用sleep函数的时候线程进入到TIMED_WAITING状态
当调用join函数的时候线程进入到Waiting状态
当等待同步代码块的时候线程可能进入阻塞状态
当调用yeild函数的时候可能执行状态会变成就绪状态，当线程被挂起的时候会变成就绪状态
就绪状态转换成执行状态是要靠线程调度器来决定不是程序可以控制的

//getState()方法会得到当前线程的状态信息
//Thread中有也对应的线程信息
public static void main(String[] args) throws InterruptedException {
        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());
            Thread. sleep(1000);
        }
        System.out.println(t.getName()+"状态"+t.getState());
    }