【java】多线程基础知识

遇到困难睡大觉哈哈

已于 2024-10-08 20:12:35 修改

阅读量1.2k

点赞数 35

文章标签： java python 开发语言

于 2024-10-08 18:42:26 首次发布

本文链接：https://blog.csdn.net/Yihong1833100198/article/details/142766562

版权

多线程

一、概念

程序：一段代码
进程：动态的概念，从程序开始执行，到最终执行结束，这个过程就是一个进程。操作系统来管理进程，其实就是一个完整的程序
多任务的操作系统:能够执行多个进程

线程：是进程中的一个控制流，程序中只有一个控制流，单线程的程序，一个程序中只有一个控制流，一个程序中设置多个控制流，每一个控制流就是一个完成一个任务
- 线程不能独立存在

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

二、如何编写多线程

多线程的执行过程

编写多线程
- 创建一个类，继续父类java.lang.Thread,重写父类中的**run()**方法，将一个线程要完成的特定任务写入该方法中
- Thread类中有特定的方法和相关的属性，能对线程进行控制，例如入start(),join()，这些方法可能会将线程由运行状态转到阻塞状态
```
public class TestCreateThread {
    public static void main(String[] args) {

        MyThread1 t1=new MyThread1("线程1");
        MyThread1 t2=new MyThread1("线程2");
        t1.start();
        t2.start();//进行线程的调度
        while(true){
            System.out.println("main方法");
        }
    }
}
```
- class 类名 extends Thread{
- 重写run()方法，该线程需要完成什么操作都放到这个方法当中
- }
- 创建线程类的对象
- 线程对象start()启动线程

编写一个类，实现一个接口java.lang.Runnable,实现接口中的run()方法，将一个线程完成特定任务

public class MyThread2 implements Runnable {
    @java.lang.Override
   //重写该接口中的run方法,将该线程需要完成的任务放到这个run()方法当中去
    public void run() {
        //完成任务的方法写在run()方法中
        while(true){
            System.out.println("这是实现了Runable的线程");
        }
    }
}

创建对象

MyThread2 dd=new MyThread2();

整体代码

public class MyThread2 implements Runnable {
    @java.lang.Override
    public void run() {
        //完成任务的方法写在run()方法中
        while(true){
            System.out.println("这是实现了Runable的线程");
        }
    }
}

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

        MyThread1 t1=new MyThread1("线程1");
        MyThread1 t2=new MyThread1("线程2");
        MyThread2 dd=new MyThread2();
        Thread t3=new Thread(dd);
        t1.start();
        t2.start();//进行线程的调度
        t3.start();
        while(true){
            System.out.println("main方法");
        }
    }
}

运行结果

创建线程对象，用dd对象做参数

Thread t3=new Thread(dd);

三、线程的生命周期：从线程创建到最终线程消亡

五个状态

新建状态：创建了线程的对象。jvm给对象分配了内存，没有表现出线程的动态特征。
就绪状态（Runnable):调用对象的start()，使线程从新建状态过渡到就绪状态。线程去线程队列中排队，等着cpu执行。
运行状态：在就绪队列中排队的线程获取了cpu的使用权，就处于运行状态cpu给线程服务，就是要执行线程的run()。

4.死亡状态：如果run()执行结束，或者在执行的过程出现异常或错误，线程处于死亡状态
阻塞状态：因为各种方法，导致线程无法获取cpu的使用权

四、线程的调度

分时调度
抢占式调度模型：优先级高抢占cpu,优先级相同时随机选一个。jvm默认是抢占式调度模型
- 注意：不一定是优先级高的先执行，只是说优先级高的先执行的可能性会大一些
- 1~10 数越大优先级越高。setPriority()设置优先级，getPriority()获取优先级
方法能对线程进行调度

sleep(ms)休眠：Thread类中的静态方法，可以让当前线程让出cpu,进入阻塞状态，一旦休眠结束，才能从阻塞状态到运行状态

实现代码

yield()让步：让当前正在运行的线程暂停，线程进入就绪状态，让系统的调度重新调度依次

代码演示

public class YieldThread extends Thread{
    public YieldThread(String name){
        super(name);
    }

    @Override
    public void run() {
        for(int i=0;i<6;i++){
            System.out.println(this.getName()+"    i="+i);
            if(i==3){
                System.out.println("线程让步");
                Thread.yield();
            }
        }
    }
}

public class YieldThread extends Thread{
    public YieldThread(String name){
        super(name);
    }

    @Override
    public void run() {
        for(int i=0;i<6;i++){
            System.out.println(this.getName()+"    i="+i);
            if(i==3){
                System.out.println("线程让步");
                Thread.yield();
            }
        }
    }
}

join()线程插队：让当前正在允许的线程暂停，进入阻塞状态，让指定的线程插队执行，知道插队的线程结束后，才能使当前线程进入就绪状态

代码演示

public class JoinThread implements  Runnable {

    @Override
    public void run() {
        for(int i=0;i<6;i++){
            System.out.println(Thread.currentThread().getName()+"    "+i);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

public class TestJoin {
    public static void main(String[] args) throws InterruptedException {
        Thread t=new Thread(new JoinThread(),"自定义线程名");
        t.start();
        for(int i=0;i<6;i++){
            System.out.println(Thread.currentThread().getName()+"======"+i);
            if(i==2){
                t.join();//让当前正在允许的线程暂停，进入阻塞状态，让指定的线程插队执行，知道插队的线程结束后，才能使当前线程进入就绪状态
            }
            Thread.sleep(500);
        }
    }
}

五、多线程同步

引出：当多个线程同时访问一个资源时如变量，就称这个资源叫做临界资源，临界资源被访问时，会产生一些问题

代码引出

public class YieldThread extends Thread{
    public YieldThread(String name){
        super(name);
    }

    @Override
    public void run() {
        for(int i=0;i<6;i++){
            System.out.println(this.getName()+"    i="+i);
            if(i==3){
                System.out.println("线程让步");
                Thread.yield();
                
            }
        }
    }
}

public class TestTickets {
    public static void main(String[] args) {
        new TicketWindow().start();
        new TicketWindow().start();
        new TicketWindow().start();
        new TicketWindow().start();

    }
}

很容易看出来，上述容易造成一张票被四个线程进行售卖的情况

改进

public class TicketWindow2 implements Runnable {
    private int ticket = 20;

    @Override
    //synchronized也可以加在方法首部，但是如果加在这个方法上，力度就比较大，一个线程就会卖完所有票，就不是多线程并发了
    public void run() {
        int i = 1;
        while (true) {
            synchronized (this) {//同步代码块
                if (ticket > 0) {
                    System.out.println("第" + i + "次卖票" + Thread.currentThread().getName() + "正在发售第" + ticket + "张票");
                    i++;
                    try {
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }

                    ticket--;
                } else {
                    break;
                }
            }
        }
    }
}

public class TestTickets {
    public static void main(String[] args) {
//        new TicketWindow().start();
//        new TicketWindow().start();
//        new TicketWindow().start();
//        new TicketWindow().start();

        TicketWindow2 ticketWindow2=new TicketWindow2();
        new Thread(ticketWindow2).start();
        new Thread(ticketWindow2).start();
        new Thread(ticketWindow2).start();
        new Thread(ticketWindow2).start();

    }
}