java 线程基础超详细笔记

剑指25校招

已于 2024-04-20 18:58:32 修改

阅读量1.2k

点赞数 29

文章标签： java 开发语言

于 2024-04-15 20:13:30 首次发布

本文链接：https://blog.csdn.net/weixin_70139631/article/details/137793694

版权

线程（基础）

线程介绍

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

线程：程序中不同的运行路线,在Java中将程序的不同运行路线的数据封装成一个线程对象

并发与并行

并发：同一时刻，多个任务交替执行，造成一种“同时执行”的错觉。

并行：同一时刻，多个任务同时执行。多核cpu可以实现并行。

并发和并行同时存在的情况：并行的设备也在并行（关键在与有没有切换进程）。

线程使用

Thread：

通过继承Thread类来创建线程。

package com.thread;

public class Thread01 {
    public static void main(String[] args) throws InterruptedException {
        //创建cat对象，可以当作线程使用
        Cat cat = new Cat();
        cat.start();
        for(int i = 1; i <=60; i++){
            System.out.println("主线程main" + i);
            Thread.sleep(1000);
        }
    }

}
class Cat extends Thread {
    @Override
    public void run() {
        int times = 0;
        while (true) {
            System.out.println("猫猫，我是小猫" + ++times);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (times == 80){
                break;
            }
        }
    }
}

1.当一个类继承了Thread类，该类就可以当作线程使用

2.我们会重写run方法，写上自己的业务代码。

3.run Thread 类实现了Runnable的run方法。

注意：不是主线程结束了，就会结束进程。所有的线程结束才会结束进程。

Runnable：

通过实现Runnable的run（）方法实现线程。

说明：java中是单继承的，在某些情况下一个类可能已经继承了某个父类，这时在用继承Thread类方法来创建线程显然不可能了。

Thread/Runnable对比

Runnable的实现方式是实现其接口即可
Thread的实现方式是继承其类
Runnable接口支持多继承，但基本上用不到
Thread实现了Runnable接口并进行了扩展，而Thread和Runnable的实质是实现的关系，不是同类东西，所以Runnable或Thread本身没有可比性。

结论，Thread和Runnable的实质是继承关系，没有可比性。无论使用Runnable还是Thread，都会new Thread，然后执行run方法。用法上，如果有复杂的线程操作需求，那就选择继承Thread，如果只是简单的执行一个任务，那就实现runnable。

线程常用方法

第一类线程方法

Thread.cuure.setName（）：设置线程名称，使之与参数name相同。

Thread.getnam（）：返回该线程的名称。

Thread.start（）：线程的启动。

Thread.sleep（）：线程休眠方法。

intertupt（）：中断线程方法。当线程被阻塞的情况下抛出InterruptedException。以此”通知“线程去做一些事情，至于做什么，做不做，实际完全是由线程内的业务代码自己决定的。

package com.thread;

public class ThreadFunction01 {
    public static void main(String[] args) throws InterruptedException {
        T t = new T();
        t.setPriority(Thread.MIN_PRIORITY);
        t.setName("江若水");
        t.start();

        for (int i =0 ; i < 5; i++){
            Thread.sleep(1000);
            System.out.println("hi!!!");
        }

        t.interrupt();
    }
}
class T extends Thread{
    @Override
    public void run(){
       while (true){
           for (int i = 0; i < 100; i++){
               System.out.println(Thread.currentThread().getName() + "正在吃包子" + (i+1) + "次" );
           }

           try {
               Thread.sleep(100000);
           } catch (InterruptedException e) {
               System.out.println(Thread.currentThread().getName() + "被interrupt了");
           }
       }
    }
}

第二类线程方法：

yield（）：线程让出资源，由cpu决定运行那个线程

join（）：线程插队，先执行插队的线程完成以后运行自身线程。

package com.thread;

public class ThreadFunction02 {
    public static void main(String[] args) throws InterruptedException {
        T2 t2 = new T2();
        t2.start();
        for (int i = 0; i < 20; i++){
            try {
                Thread.sleep(1000);
                System.out.println(Thread.currentThread().getName() + "正在吃包子" + (i+1) + "次" );
            } catch (InterruptedException e) {
                System.out.println(Thread.currentThread().getName() + "被interrupt了");
            }
            if (i == 5){
                System.out.println("大哥先吃");
                //                t2.join();
                Thread.yield();
                System.out.println("我在吃");
            }
        }
    }
}
class T2 extends Thread{
    @Override
    public void run(){
        for (int i = 0; i < 20; i++){
            try {
                Thread.sleep(1000);
                System.out.println(Thread.currentThread().getName() + "正在吃包子" + (i+1) + "次" );
            } catch (InterruptedException e) {
                System.out.println(Thread.currentThread().getName() + "被interrupt了");
            }
        }
    }
}

用户线程和守护线程

用户线程：当存在任何一个用户线程未离开，JVM是不会离开的。

守护线程：如果只剩下守护线程未离开，JVM是可以离开的。

在Java中，制作守护线程非常简单，直接利用.setDaemon(true)

线程的生命周期（线程的六种状态）

NEW

尚未启动的线程处于此状态。

RUNNABLE（可细化为）

在Java虚拟机中执行的线程处于此状态。

Ready和Running

BLOCKED

被阻塞等待监视器锁定的线程处于此状态。

WAITNG

正在等待另一个线程执行特定动作的线程处于此状态。

TIME_WATING

正在等待另一个线程执行动作达到等待时间的线程处于此状态。

TERMINATEN

已退出的线程处于此状态。

状态转化图：

查看线程状态代码：

package com;

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

    }
}

Synchronized（非公平的）

线程同步机制

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

同步售票演示：

package com.syn;

import com.syn.*;

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

        SellTicket01 sellTicket03 = new SellTicket01();

        new Thread(sellTicket03).start();
        new Thread(sellTicket03).start();
        new Thread(sellTicket03).start();

//        SellTicket01 sellTicket01 = new SellTicket01();
//        SellTicket01 sellTicket02 = new SellTicket01();
//        SellTicket01 sellTicket04 = new SellTicket01();
//
//
//        sellTicket01.start();
//        sellTicket02.start();
//        sellTicket04.start()
//
//    总结：
//        第一种方式：三个线程共享同一个 SellTicket01 实例，可能导致线程安全问题。
//        第二种方式：每个线程有自己的 SellTicket01 实例，线程安全，但可能增加内存使用。
//        选择哪种方式取决于您的具体需求。如果 SellTicket01 实例的状态不需要在多个线程之间共享，
//        或者您可以确保线程安全，那么第二种方式可能更合适。如果状态需要在多个线程之间共享，
//        那么您需要确保在 SellTicket01 类中采取适当的同步措施来避免线程安全问题。
//
    }
}
//使用Thread方式
class  SellTicket01 extends Thread{
    private static int ticketNum = 100;
    private boolean loop = true;

    public synchronized void sellTicket(){
        if (ticketNum <=0 ){
            System.out.println("售磬");
            loop = false;
            return;
        }

        try {

            System.out.println("窗口" + Thread.currentThread().getName() + "售出一张票"
                    + "剩余票数" + (--ticketNum));
            Thread.sleep(800);

        } catch (InterruptedException e) {
            e.printStackTrace();
        }
//            Thread.currentThread().setName("机票售票口");
    }
    @Override
    public  void run(){//同步方法,在同一时刻,只能有一个线程执行run方法
        while (loop){
            sellTicket();

        }
    }
}

互斥锁

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

注意：要求多线程的锁对象必须是同一个。

死锁

基本介绍

多个线程都占用了对方的锁资源，但不肯相让，导致了死锁。

释放锁

下面操作会释放锁：

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

下面操作不会释放锁：

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

注意：suspend（）和resume（）来控制线程，方法不再推荐使用。