Java多线程-----入门

Yekindar3

已于 2023-05-13 21:35:21 修改

阅读量54

点赞数 1

文章标签： java jvm 开发语言

于 2023-05-13 21:31:41 首次发布

本文链接：https://blog.csdn.net/m0_63200605/article/details/130023185

版权

线程的生命周期

(1)新建状态（New）：当线程对象创建后，即进入了新建状态,直到被start()方法调用.

(2)就绪状态（Runnable）:当调用线程对象的start()方法,线程即进入就绪状态。

(3)运行状态（Running）：当CPU开始调度处于就绪状态的线程时，此时线程才得以真正的执行，即进入到运行状态。

(4)阻塞状态（Blocked）:处于运行状态中的线程由于某种原因，暂时放弃对CPU的使用权，停止执行，此时进入阻塞状态，直到其进入到就绪状态，才有机会再次被CPU调用以进入到运行状态。根据阻塞产生的原因不同，阻塞状态又可以分为三种：

a.等待阻塞：运行状态中的线程执行wait（）方法，使本线程进入到等待阻塞状态。

b.同步阻塞：线程在获取synchronized同步锁失败（因为锁被其他线程所占用），它会进入同步阻塞状态

c.其他阻塞：通过调用线程的sleep（）或join()发出了I/O请求时，线程会进入到阻塞状态，当sleep（）状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入到就绪状态。

(5)等待状态（Wait）：当前线程等待其他线程的通知。

(6)死亡状态（Dead）：线程执行完了或者因为异常退出了run（），该线程结束生命周期

阻塞状态和等待状态类似，他们两者最大的区别在于，阻塞状态在尝试获取执行权，而等待状态既没有执行权，也没有在准备争夺执行权.

线程的三种启动方式

继承Thread类

继承Thread类是实现多线程的最简单方法之一。继承Thread类后，需要重写run()方法，该方法中的代码将在新线程中执行。通过调用start()方法启动线程，线程会自动执行run()方法中的代码。

继承Thread类的好处是使用简单，可以直接调用start()方法启动新线程。但是缺点是当需要在多个类之间共享数据时，需要使用静态变量或者全局变量，会增加程序的复杂度和不稳定性。

实现Runnable接口

实现Runnable接口是一种更灵活的实现多线程的方法。实现Runnable接口后，需要重写run()方法，该方法中的代码将在新线程中执行。通过创建Thread对象来启动线程，并将Runnable对象传递给Thread对象的构造方法。

实现Runnable接口的好处是可以避免单继承的限制，同时可以更好地进行多线程共享数据。多个线程可以共享同一个Runnable对象，从而实现数据的共享和同步。

实现Callable接口

实现Callable接口是一种更高级的实现多线程的方法。与Runnable接口不同，实现Callable接口的线程可以返回一个结果，该结果可以通过Future对象获取。

实现Callable接口的好处是可以返回一个结果，从而更好地处理多线程操作的返回值。此外，Callable接口支持泛型，可以更好地处理不同类型的结果。


class thread_1 extends Thread{
    public void run(){
        System.out.println("继承Thread类");
    }
}

public class Demo {
    public static void main(String[] args) {
       thread_1 t1=new thread_1();
       t1.start();
    }
}

class thread_1 implements Runnable{
    public void run(){
        System.out.println("继承接口Runnable");
    }
}

public class Demo {
    public static void main(String[] args) {
       thread_1 t1=new thread_1();
       Thread t=new Thread(t1);
       t.start();
    }
}

class thread_1 implements Callable<String> {
    public String call() throws Exception {
        System.out.println("继承接口Callable");
        return "返回值";
    }
}

public class Demo {
    public static void main(String[] args) {
        // 创建Callable实现类对象
       thread_1 t1=new thread_1();
        // 将callable作为参数创建FutureTask对象
       FutureTask<String> futureTask=new FutureTask<>(t1);
        // 将futureTask作为参数创建线程
       Thread t=new Thread(futureTask);
       t.start();
    }
}

既然有三种继承方式，那我们在编写线程的时候如何选择呢？

第一种直接继承Thread类，虽然代码量有所减少，更简洁，但是java只支持单继承类，这也就导致了代码不能够继承其他类，所以在有其他类继承需求的时候，会变得不够灵活.

第二三种都是接口，java支持多继承接口，所以比第一种更加灵活，区别在于，第三种方法可以返回值，当你想有返回值的时候，你就可以选择第三种.

线程安全问题

为什么有线程安全问题

引起线程安全问题的是多线程吗?

很明显不是，下面有一个很经典的例子，来说明这个问题

我们声明两个线程，一个线程对变量进行10000次自增，另一个线程对变量进行10000次自减，按照我们所想，该变量应该为0,但结果却不为0

class Counter {
    private int count;
    public void increase() {
        ++this.count;
    }
    public void decrease(){
        --this.count;
    }
    public int getCount() {
        return this.count;
    }
}

public class Demo {
    private static final int CNT = 50000;
    private static final Counter counter = new Counter();
    public static void main(String[] args) throws InterruptedException {

        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < CNT; i++) {
                counter.increase();
            }
        });
        Thread thread2 = new Thread(() -> {
            for (int j = 0; j < CNT; j++) {
                counter.decrease();
            }
        });

        thread1.start();
        thread2.start();

        thread1.join();
        thread2.join();

        System.out.println(counter.getCount());
    }
}

接下来在举一个例子，来说明出现问题的地方究竟在哪，和上面不同的是，线程1对一个变量自增，线程2对另一个变量自减.

class Counter {
    private int count;
    private int count1;
    public void increase() {
        ++this.count;
    }
    public void decrease(){
        --this.count1;
    }
    public int getCount() {
        return this.count;
    }
    public int getCount1(){
        return this.count1;
    }
}

public class Demo {
    private static final int CNT = 10000;
    private static final Counter counter = new Counter();
    public static void main(String[] args) throws InterruptedException {

        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < CNT; i++) {
                counter.increase();
            }
        });
        Thread thread2 = new Thread(() -> {
            for (int j = 0; j < CNT; j++) {
                counter.decrease();
            }
        });

        thread1.start();
        thread2.start();

        thread1.join();
        thread2.join();

        System.out.println(counter.getCount());
        System.out.println(counter.getCount1());
    }
}

结果又正常了，由此可见多线程并不是罪魁祸首，而是多线程同时操作一个共享变量时，就会出现问题!

多线程引起安全问题的本质

多个线程同时对同一个共享资源进行读写操作，导致数据不一致或者数据丢失。操作系统种线程的调度是抢占式的，这也就导致了线程调度执行的顺序也存在不确定性.比如第一种情况看似一个自增，一个自减(自增自减的过程其实有三步，第一步是取地址里的值，自增或自减，然后返回值)两个线程在抢执行权，自增线程在返还值的时候，就被自减取走了原先的值,这就导致了结果的不确定性.对于一个共享变量的自增自减是跟执行顺序息息相关的，所以线程的执行顺序会导致结果也不确定.对于多线程引起的执行顺序不确定性导致的程序bug是多线程的安全问题.

如何解决线程安全问题

加锁!!!

为了解决由于“抢占式执行”所导致的线程安全问题，我们可以对操作的对象进行加锁，当一个线程拿到该对象的锁后，会将该对象锁起来，其他线程如果需要执行该对象的任务时，需要等待该线程运行完该对象的任务后才能执行。(比如去银行取钱，如果ATM机里都占满了人，我们需要等待里面的人取完钱，打开门之后，我们才能进去取钱.)

加锁的几个方法

1.同步代码块

//可以在一个对象前加上static表示唯一
 
synchronized (锁对象，一定要唯一) {
        方法体;
            
        }

锁对象一定要唯一，是因为锁的主要作用是保证同一时刻只有一个线程访问共享资源，从而避免多个线程同时对该资源进行修改而导致的线程安全问题。如果使用不同的锁对象来控制对共享资源的访问，就会出现多个线程同时访问该资源的情况，从而导致线程安全问题的发生。

2.同步方法


public synchronized void Money(int money) {
      方法体;
    }

同步方法底层原理：

同步方法其实底层也是有隐式锁对象的，只是锁的范围是整个方法代码。

如果方法是实例方法：同步方法默认用this作为的锁对象。但是代码要高度面向对象！

如果方法是静态方法：同步方法默认用类名.class作为的锁对象。

3.Lock锁


 //final修饰后：锁对象是唯一和不可替换的
private final Lock lock = new ReentrantLock();
 
public void Money(int money) {
        lock.lock();
        try {
            if (this.money >= money) {
                 System.out.println("取钱成功！");
            }else {
                System.out.println("余额不足！");
        }
        } finally {
            lock.unlock();
        }
    }

锁的升级过程

CAS算法

CAS（Compare and Swap）算法是一种乐观锁技术，它的基本思想是：先读取内存中的值，然后和期望值进行比较，如果相等，则将新值写入内存；否则重新读取内存中的值，再次进行比较，直至成功为止。CAS算法的核心是CPU提供的CAS指令，它可以实现原子性的读取和修改操作。在锁的升级过程中，CAS算法可以用来实现从偏向锁到轻量级锁的升级过程，以及从轻量级锁到重量级锁的升级过程。

偏向锁：当一个线程访问一个对象时，如果该对象没有被锁定，JVM会将该线程标记为偏向锁，并将对象头中的线程ID设置为该线程的ID。此后，该线程再次访问该对象时，无需进行同步操作，直接进入偏向锁模式，提高了程序的运行效率。

轻量级锁：当一个线程访问一个对象时，如果该对象已经被锁定，JVM会将对象头中的指针指向当前线程的栈帧，然后使用CAS算法尝试将对象头中的指针设置为锁对象。如果CAS操作成功，则表示当前线程获取了锁，进入轻量级锁模式；否则，表示其他线程正在竞争该锁，当前线程会进行自旋等待。

重量级锁：当一个线程访问一个对象时，如果该对象已经被锁定，而且其他线程正在等待获取该锁，JVM会将当前线程阻塞，直到其他线程释放该锁。这种锁的开销比较大，适用于多线程竞争激烈的情况。

通过CAS算法，可以实现锁的升级过程，从而提高程序的运行效率，并减少锁竞争带来的性能损失。

AQS算法

AQS算法的核心是一个FIFO的双向队列，用于存储等待获取锁的线程。每个节点都包含了一个状态值，表示该节点所代表的线程的状态。当一个线程尝试获取锁时，如果发现锁已经被其他线程持有，则该线程会被封装成一个节点，然后被加入到等待队列中，进入阻塞状态。当锁被释放时，AQS算法会从等待队列中取出一个节点，唤醒该节点所代表的线程，使其继续执行。

AQS算法支持独占锁和共享锁两种模式。独占锁模式用于保证同一时刻只有一个线程能够访问共享资源，例如ReentrantLock类就是基于独占锁模式实现的；共享锁模式则用于允许多个线程同时访问共享资源，例如ReadWriteLock类就是基于共享锁模式实现的。

AQS算法还支持条件等待，即让线程等待某个条件的发生，然后再继续执行。当一个线程调用await()方法时，它会被封装成一个节点并加入到条件队列中，进入阻塞状态。当其他线程调用signal()或signalAll()方法时，AQS算法会从条件队列中取出一个节点，唤醒该节点所代表的线程，使其继续执行。

线程池的核心参数

核心线程:即使没有任务处理，也不会被销毁的线程，线程一直存在。核心线程的作用是1，响应任务速度更快，不需要去new一个新的线程对象。2，减少线程创建和销毁的资源开销3，保证任务执行的顺序，当线程中线程空闲时，调用空闲线程，而不是临时线程。

任务队列：表示线程池中用于存储任务的队列。当线程池中的线程数达到核心线程数时，新的任务将被放入任务队列中等待执行。

临时线程:当核心线程和任务队列都不为空时，调用临时线程来处理后续排队的任务.

线程空闲时间：表示线程池中的线程在空闲状态下可以存活的最长时间。当线程池中的线程数超过核心线程数，并且处于空闲状态时，它们将在指定的时间内被销毁。

当任务多于核心线程+任务队列+临时线程线程池将拒绝执行该任务并抛出异常。

下面是一个线程池的小例子:

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadPoolExample {
    public static void main(String[] args) {
        // 创建线程池，包含2个核心线程
        ExecutorService executor = Executors.newFixedThreadPool(2);

        // 提交10个任务进行执行
        for (int i = 0; i < 10; i++) {
            executor.submit(new Task(i));
        }

        // 关闭线程池
        executor.shutdown();
    }

    static class Task implements Runnable {
        private int id;

        public Task(int id) {
            this.id = id;
        }

        public void run() {
            System.out.println("Task " + id + " is running on thread " + Thread.currentThread().getName());
        }
    }
}