Java线程

最新推荐文章于 2024-08-16 23:08:28 发布

Leslie Fu

最新推荐文章于 2024-08-16 23:08:28 发布

阅读量208

点赞数

分类专栏： JAVA学习文章标签： java 开发语言后端

本文链接：https://blog.csdn.net/Luyun233/article/details/122455291

版权

JAVA学习专栏收录该内容

6 篇文章 2 订阅

订阅专栏

Java线程

简介

进程

在操作系统中独立运行的程序，一个运行的程序就对应着一个进程。在操作系统中可以同时运行多个程序。

线程

进程内部的一个执行单元，用来执行进程中的某个功能。在程序内部可以同时执行多个线程实现多个功能。

特性：

一个进程可以包含多个线程
进程是线程的容器
一个进程中的多个线程共享该进程的所有资源

创建线程

两种方式：
继承Thread类
实现Runnable接口

当前线程对象：Thread.currentThread()主线程：main，自定义线程：Thread-编号

继承Thread类

定义一个类继承自Thread类并重写run方法
建立一个线程实例
调用start方法启动线程，**不能直接调用run方法！！！**线程创建后并不一定立即执行，需要得到CPU时间片才会执行（具体可查阅操作系统相关资料）

实现Runnable接口

同样是定义一个类，实现Runnable接口的run方法
创建实现类的一个实例
创建线程实例，并传入实现类
调用start方法启动线程

两种实现方式的对比

继承自Thread类

线程执行的代码放在自定义的子类的重写run方法中
由于单重继承的规定，无法继承其他类

实现Runnable接口（推荐）

线程执行的代码放在接口实现类的run方法中
可以继承其他类
适合多个相同程序代码的线程去处理同一个资源
增强了程序的健壮性

线程的生命周期

在这里插入图片描述相关方法：

方法	作用	说明
start	启动线程，让线程进入就绪态
sleep	休眠线程，线程由执行态进入阻塞态	静态方法
yield	暂停执行线程，线程由执行态进入就绪态	静态方法
join	暂停执行线程，让另一个线程执行完毕后再执行，当前进程进入阻塞态
interrupt	中断线程的休眠或等待状态

线程优先级

我们可以查看Thread类关于线程优先级的定义，优先级用int类型的数据表示，最小为1最大为10，默认优先级为5。线程的优先级可以调用getPriority()方法查看。设置优先级只能提高线程被优先执行的概率，并不是绝对意义上的优先。

public static final int MIN_PRIORITY = 1;
public static final int NORM_PRIORITY = 5;
public static final int MAX_PRIORITY = 10;

守护线程

public static void setDaemon(boolean on)方法在传入参数为真时将该线程标记为守护线程。

当正在运行的线程都是守护线程时，Java虚拟机退出
该方法必须在启动线程之前调用
main线程是用户线程

守护线程典型使用场景
垃圾回收器就运行在守护线程中

线程安全问题

当多线程访问共享数据（临界资源）时，可能出现，由于CPU的切换，导致一个线程只执行了一部分，还没执行完就被换下CPU，此时另一个线程参与进来，导致数据发生异常的情况，这种问题就是线程安全问题。

解决方案：线程同步机制Synchronized + 锁

被Synchronized包围的代码块，称为同步代码块
被Synchronized包围的方法，称为同步方法（更常用）
- 普通方法，默认的是当前类锁
- 静态方法，默认的是当前类的Class对象锁
锁，也称为对象锁，每个对象都自带一个锁，且不同对象的锁是不一样的

执行过程

线程执行同步代码块或者同步方法时，必须获得特定对象的锁才行
一旦对象的锁被获取，那么该对象不再有锁，直到线程执行完同步代码块或同步方法时，才会释放对象的锁
如果线程无法获取特定对象上的锁，则会进入对象的锁池中进行等待，直到锁被归还给该对象，锁池中的线程会去竞争这个锁
只需要将关键的代码放进同步代码块或同步方法中，不然就和单线程没区别

接下来看一个实例：
创建一个Singleton类，每当创建该类的实例时，输出构造函数，并且定义了一个成员方法：getInstance如果变量instance是空指针则新建一个Singleton对象。

public class Singleton {
    private static Singleton instance;
    private Singleton(){
        System.out.println("Singleton.Singleton()");
    }
    public static synchronized Singleton getInstance() throws InterruptedException {
        if(instance == null) {
            //Thread.sleep(100);
            instance = new Singleton();
        }
        return instance;
    }
}

正常情况下，两个进程执行getInstance方法，只会创建一个Singleton对象（如果不太能理解，请多看几遍代码），得到如下结果：

Singleton.Singleton()
securety.Singleton@6c197f00
securety.Singleton@6c197f00

但是，如果其中一个线程在执行语句if(instance == null)后，instance = new Singleton()前进行了线程切换，因为instance依然是null，所以另一个线程会新建一个Singleton对象，而原来的线程也会因为继续执行代码而新建第二个对象，得到如下结果：

Singleton.Singleton()
securety.Singleton@3f6d4362
Singleton.Singleton()
securety.Singleton@67413298

可以看到，确实新建了两个对象，如果将getInstance方法重新定义为同步方法，就能避免两个线程访问该方法的线程安全问题。

线程同步的优缺点

优点：解决了线程安全问题，使代码在某一时间只能被某一线程访问
缺点：由于需要进行锁的判断，消耗资源，效率变低

线程通信

锁池和等待池

每个对象都自带锁池和等待池

锁池：

当线程执行Synchronized块时无法获取特定对象上的锁，会进入该对象锁池
当锁被归还给对象时，锁池中的线程会竞争锁
获取对象锁的进程将执行对应同步方法，执行完毕后会释放锁

等待池：

当线程获取锁后，可以调用wait()方法放弃锁，进入对象等待池
当其他线程调用该对象的notify()或notifyAll()方法时，等待池中的线程会被唤醒，进入该对象的锁池
当线程获取对象的锁后，将从上次调用wait方法的位置开始继续执行

方法	作用	说明
wait	使线程放弃锁，线程进入等待池	可以调用等待超时时间，超时后线程会自动唤醒
notify	随机唤醒等待池中的一个线程进入锁池	唤醒的是特定对象的等待池中的进程
notifyAll	唤醒等待池中的所有线程

这三个方法都只能synchronize中使用，只有获取了锁的线程才能调用这些方法
等待和唤醒必须使用的同一对象

生产者-消费者问题

生产者-消费者问题是多线程同步的一个经典问题，即并发协作的问题，所谓生产者-消费者问题，实际上是包含了两种线程：生产者线程、消费者线程

生产者作用：

生产商品并放入缓冲区
缓冲区满时，生产者不可再生产商品

消费者线程：

从缓冲区中购买商品
当缓冲区为空时，消费者不可再购买商品

当缓冲区的商品变空时，消费者进入等待池，并在生产者生产商品后由生产者进程唤醒；同理当缓冲区的商品满时，生产者进入等待池，等待消费者将其唤醒。

根据分析，假设生产者2s生产一个商品，生产者类定义如下：

public class Producer extends Thread{
    private String name;
    private ProducePool pool;
    public Producer(String name, ProducePool pool) {
        this.name = name;
        this.pool = pool;
    }

    @Override
    public void run() {
        while(true){
            synchronized (pool){
                if(pool.isFull()) {
                    try {
                        pool.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

                else{
                    pool.put();
                    System.out.println("生产者" + this.name + "生产了一个商品，当前剩余商品数为： " + pool.getNum());
                    pool.notifyAll();
                }
            }
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
}

消费者类定义如下：

public class Consumer extends Thread{
    private String name;
    private ProducePool pool;
    public Consumer(String name, ProducePool pool) {
        this.name = name;
        this.pool = pool;
    }

    @Override
    public void run() {

        while(true){
            synchronized (pool){
                if(pool.isEmpty()) {
                    try {
                        pool.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

                else{
                    pool.get();
                    System.out.println("消费者" + this.name + "消费了一个商品，当前剩余商品数为： " + pool.getNum());
                    pool.notifyAll();
                }
            }
        }

    }
}

缓冲区定义如下：

public class ProducePool {
    private int num;
    private static final int MAX_COUNT = 20;

    public void put(){
       num++;
    }

    public void get(){
        num--;
    }

    public int getNum(){
        return num;
    }

    public boolean isEmpty(){
        return this.num == 0;
    }

    public boolean isFull(){
        return this.num == MAX_COUNT;
    }
}