一文搞懂线程！！

Java多线程

线程的状态

public enum State{
   
   
  NEW RUNNABLE,//新生态，分为ready(准备状态)，running(运行状态) 
  BLOCKED,//阻塞 线程在运行过程中始终在占用CPU的时间 只有当被阻塞了 才不会占用CPU的时间
  WAITING TIMED_WAITING,//一直等 有时限的等待
  TERMINATED//终止态
}

线程的等待状态与阻塞状态

//等待状态
Object.wait()// 使当前线程进入等待状态，等待其他线程调用 Object.notify() 或 Objec.notifyAll() 方法唤醒它；
                     // 传入的参数为timeOut 以ms为单位
Thread.join()// 等待指定线程执行完毕，进入等待状态。
                   // 在其他线程中调用该线程的join()方法则其他线程会等待该线程执行完毕后再继续执行线程

//唤醒等待状态
lock.notifyAll()// 与wait()方法对应，能够唤醒两条以上的线程
lock.notify()// 唤醒两条线程

//阻塞状态
thread.sleep()// 休眠指定的时间

多线程并发

并发指的是多个任务在时间上重叠进行，可以是线程交替执行任务，也可以是同时执行任务。具体取决于操作系统和硬件的支持。

在单核处理器上，实际上只有一个线程能够被执行，但多个线程可以通过快速的切换（时间片轮转）来模拟同时执行的效果。这种情况下，多个线程会交替地在处理器上执行各自的任务，使得任务在时间上重叠进行，实现并发。

在多核处理器或多处理器系统上，多个线程可以被同时执行，每个线程可以在不同的处理器核心上执行自己的任务，从而实现真正的并行执行。然而，当多个线程同时访问共享的资源（如变量、对象、文件等）时，可能会导致数据不一致或竞态条件等问题。为了确保线程安全，可以使用同步机制来控制对共享资源的访问。

多线程并发并不一定意味着多个线程在同一时刻同时进行计算操作，而有可能是指多个线程在同一时间段内交替执行。

并行指的是在不同的处理单元上面。

class Counter {
   
   
    private int count;
    public synchronized void increment() {
   
   
        count++;
    }

    public synchronized int getCount() {
   
   
        return count;
    }
}

public class Main {
   
   
    public static void main(String[] args) throws InterruptedException {
   
   
        Counter counter = new Counter();
        Thread thread1 = new Thread(() -> {
   
   
        for (int i = 0; i < 1000; i++) {
   
   
            counter.increment();
        }
    });

    Thread thread2 = new Thread(() -> {
   
   
        for (int i = 0; i < 1000; i++) {
   
   
            counter.increment();
        }
    });

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

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

    System.out.println("Count: " + counter.getCount()); // 输出结果应为2000
}
}

而是通过join()方法的阻塞机制，确保在主线程输出结果之前，thread1和thread2线程完成了各自的计数操作。join()方法可以用于在多线程环境中协调线程的执行顺序:

// 等待线程执行完毕
try {
   
   
    thread.join();
} catch (InterruptedException e) {
   
   
    // 处理中断异常
}

并发类

concurrentHashMap的原理：分段锁，每一段都给它开一扇门上一把锁

import java.util.concurrent.ConcurrentHashMap;

public class ConcurrentHashMapExample {
   
   
    public static void main(String[] args) {
   
   
        ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();

        // 创建多个线程，同时对 ConcurrentHashMap 进行操作
        Thread thread1 = new Thread(() -> {
   
   
            for (int i = 1; i <= 100; i++) {
   
   
                map.put("Key" + i, i);
            }
        });

        Thread thread2 = new Thread(() -> {
   
   
            for (int i = 101; i <= 200; i++) {
   
   
                map.put("Key" + i, i);
            }
        });

        Thread thread3 = new Thread(() -> {
   
   
            for (int i = 201; i <= 300; i++) {
   
   
                map.put("Key" + i, i);
            }
        });

        // 启动线程
        thread1.start();
        thread2.start();
        thread3.start();

        // 等待所有线程执行完毕
        try {
   
   
            thread1.join();
            thread2.join();
            thread3.join();
        } catch (InterruptedException e) {
   
   
            e.printStackTrace();
        }

        // 输出 ConcurrentHashMap 中的数据
        System.out.println("ConcurrentHashMap: " + map);
    }
}

注意：因为每个线程的执行速度和竞争情况可能不同，因此无法确定不同线程之间操作的先后顺序。主线程调用join()方法并不能决定线程之间的执行顺序。concunrrentHashMap中的数据是三个线程共同完成之后的结果。

高阶线程

共享锁与排他锁的关系

1. 多个线程可以同时持有共享锁，但只有一个线程可以持有排它锁（Exclusive Lock）；
2. 当一个线程持有共享锁时，其他线程可以继续持有共享锁，但不能持有排它锁；
3. 当一个线程持有排它锁时，其他线程不能持有共享锁或排它锁；
4. 共享锁不会阻塞其他线程持有共享锁，但会阻塞其他线程持有排它锁；
5. 共享锁可以降级为排它锁，但排它锁不能升级为共享锁。

线程安全

尽管线程之间的栈内存独立为线程提供了一定的隔离，但仍需要额外的线程安全机制来处理共享数据的访问。（对堆内存中的数据而言，显然没有办法保证线程安全。）
线程安全（Thread safety）是指在多线程环境下，对共享资源的访问和操作能够正确地执行而不会导致数据不一致、并发错误或其他不可预期的问题。

具体来说，线程安全的定义包括以下几个方面：

1. 原子性（Atomicity）：对于多个线程同时执行的操作，要么完全执行成功，要么完全不执行，不会出现中间或部分执行的情况。多个线程对共享资源的操作应该是原子的，不会相互干扰。

   atomic

2. 可见性（Visibility）：一个线程对共享资源的修改对其他线程应该是可见的。当一个线程修改了共享资源的值后，其他线程应该能够立即看到这个修改。

   volatile

3. 有序性（Ordering）：多线程环境下的操作应该按照一定的顺序进行，以确保正确的执行。线程之间的操作可能存在并发冲突，需要通过合适的同步机制来保证操作的有序性。

   通过在各线程之间调用join()方法来调整线程的执行顺序

atomicxxx 原子类变量

“要么成功要么失败”，在多线程环境下是线程安全的，不会被其他线程中断或者影响，不需要其他的同步措施。

在多线程环境下的lambda表达式下

 .map(list->{
   
   
                                // 变量是无法传到lambda表达式里面 通过原子计算
                                AtomicInteger directSaleCount = new AtomicInteger(0);
                                AtomicInteger indirectSaleCount = new AtomicInteger(0);
                                AtomicInteger totalDays = new AtomicInteger(0);
                                SortedMap<Integer,String> map = new TreeMap<>();// 行为模式--时间 选用treeMap的原因是自动根据key排序，并且firstKey()能够获取最小键值对应的值
                                list
                                        .stream()
                                        .sorted(Comparator.comparing(UserAct::getTime))
                                        .forEach(act -> {
   
   
                                           if(act.getBehaviourType()==4){
   
   
                                               if(map.isEmpty()){
   
   
                                                   directSaleCount.getAndIncrement();
                                               }else {
   
   
                                                   final String startTime = map.get(map.firstKey());
                                                   final String stopTime = act.getTime();
                                                   indirectSaleCount.getAndIncrement();
                                                   try {
   
   
                                                       final long start = sdf.parse(startTime).getTime();
                                                       final long stop = sdf.parse(stopTime).getTime();
                                                       totalDays.getAndAdd((int)((stop-start)/DAY_IN_MILLIS));
                                                   } catch (ParseException ex) {
   
   
                                                       ex.printStackTrace();
                                                   } finally{
   
   
                                                       map.clear();
                                                   }
                                               }
                                           }
                                           map.put(act.getBehaviourType(),act.getTime());
                                        });
                                // 没有自动拆装箱的机制，需要通过对象去get到值
                                return new int[]{
   
   directSaleCount.get(),indirectSaleCount.get(),totalDays.get()};
                            })

普通变量并不是线程安全的，所以此处应用原子类变量。

volatile xxx 非线程安全型可见性变量

volatile 变量适用于只有一个线程写入，多个线程读取的场景，例如线程间的通信标志位。而 Atomic 类适用于多个线程对同一个变量进行复合操作的场景，例如计数器、累加器等。

volatile适合只需要读的或者只有一个线程改的，而atomic适合有多个线程改的。

一个卖票/造票，多人买票

 static volatile int ticket = 20;// 被多个客户共享的票。

jdk写的比我们重构的线程安全，但并不是绝对安全。所谓的线程安全指的是数据一致性，即我在修改的时候，你是不能修改的，你只能看到我修改前或后的数据，达成线程安全需要加锁。对于要求绝对线程安全的，我们有替代品。

//The number of times this HashMap has been structurally modified 记录增删运行次数
transient int modCount;

//在查询数据的时候，我先取modCount，当迭代这条数据的时候，有人做了一个新增操作,这个时候的modCount和前面的modCount不同，这个时候就会报异常。
//ConcurrentModificationException 实时修改异常

生产者消费者模式

public class ProducerAndConsumer {
   
   

    // 共享的数据都需要设置为静态的。
    final static Object lock = new Object();// 共享数据->共享同一把锁。
    static volatile int ticket = 20;// 被多个客户共享的票。
    // 生产者：1.在造票后进入阻塞状态 2.造票后通知全部消费者
    static void produce(){
   
   
        final Thread thread = new Thread(() -> {
   
   
            final String name = Thread.currentThread().getName();
            while (true) {
   
   
                // 上锁方式1：同步代码块
                synchronized (lock) {
   
   
                    if (ticket > 0) {
   
   
                        try {
   
   
                            lock.wait(5000);// 阻塞
                        } catch (InterruptedException e) {
   
   
                            e.printStackTrace();
                        }
                    } else {
   
   
                        ticket += 20;
                        System.out.printf("%s 造票 %d 张\n",name,20);
                        lock.notifyAll();// 两条以上的线程 lock.notify():两条线程之间
                    }
                }
            }
        });
        thread.setName("车站");
        thread.start();
    }

    static void consume(int i){
   
   
        final Thread thread = new Thread(() -> {
   
   
            final String name = Thread.currentThread().getName();
            while(true){
   
   
                synchronized (lock){
   
   
                    if(ticket>0){
   
   
                        ticket--;
                        System.out.printf("%s 抢到一张票，剩余 %d 张\n",name,ticket);
                        try {
   
   
                            Thread.sleep(1000);// 抢票输出过程的阻塞
                        } catch (InterruptedException e) {
   
   
                            e.printStackTrace();
                        }
                    }
                }
            }
        });
        thread.setName("黄牛"+i);
        thread.start();
    }
    public static void main(String[] args) {
   
   
        produce();
        for (int i = 1; i <= 5; i++) {
   
   
            consume(i);
        }
    }
}

1. java中任意对象都作为锁，因为Object是锁。

2. 在这其中锁和票都是共享的，都应该定义为静态变量

   共享锁：多个线程能够共享读取其中的数据，但是不能进行写操作。（所有买家只能获取票数，但无法修改票数）

3. 熟悉Thread.sleep()以及Thread.currentThread.getName()的应用