多线程Thread

Dear 丶 2022-05-16 11:04 298阅读 0赞

--------------------

\#\#java中的线程分类

**User Thread 用户线程**

运行在前台，执行具体任务:

比如程序的主线程、连接网络的子线程等等都是用户线程，如main()；

执行具体任务的线程都是属于用户线程，看得清摸不到；

**Daemon Thread 守护线程**

运行在后台，为其它前台线程服务:

一旦所有的用户线程都结束运行，守护线程就会随着JVM一起结束工作

应用：比如数据库连接池中的监测线程；JVM虚拟机启动后的监测线程，JAM垃圾回收线程等;

\#\#线程创建的方式

**Thread** ——直接继承Class Thread实现

package com.thread.train;
    
    public
    class TicketWindow{
    
    public static void main(String[] args) {
    
    TicketThread ali = new TicketThread("阿狸XD");
           TicketThread miyamoto = new TicketThread("宫本》");
           TicketThread fire = new TicketThread("火舞~");
    
           //抢占CPU资源，开始买票
           ali.start();
           miyamoto.start();
           fire.start();
    
       }
    
    }
    
    class TicketThread extends Thread{
    
    //总票数
       private int ticketCount = 10;
       //窗口名 每个窗口相当于一个线程，共同卖火车票
       private String windowName;
    
       //设置当前窗口名
       public TicketThread(String name){
    this.windowName = name;
       }
    
    @Override
       public void run() {
    int count = 0 ;
    
           while (ticketCount > 0){
    try {
    //卖票
                   ticketCount--;
                   System.out.println(windowName + "卖了1张，还剩 " + ticketCount +" 张票");
                   count++;
                   System.out.println(windowName + "一共卖了 " + count +" 张票");
    
                   Thread.sleep(100);
               } catch (InterruptedException e) {
    e.printStackTrace();
               }
    }
    }
    }

测试：

Runnable ——需要实现interface Runnable

package com.thread.train;
    
    public class TicketWindowRunnable{
    
    
    public static void main(String[] args) {
    TicketRunnable TicketRunnable = new TicketRunnable();
    
           //默认构造方法，可以传名字。创建三个线程,传递的同一个对象，所以资源可以共享
           Thread ioriYagami = new Thread(TicketRunnable,"八神庵");
           Thread leonaHeidern = new Thread(TicketRunnable,"莉安娜");
           Thread Orochi = new Thread(TicketRunnable,"大蛇");
           //抢占CPU资源，开始买票
           ioriYagami.start();
           leonaHeidern.start();
           Orochi.start();
    
       }
    }
    
    class TicketRunnable implements Runnable {
    //总票数
       private int ticketCount = 10;
    
       @Override
       public  void run() {
    int count = 0;
           while (ticketCount > 0){
    try {
    //买票
                   ticketCount -- ;
                   count ++;
                   //获取当前线程
                   System.out.println(Thread.currentThread().getName() + "卖了1张，还剩 " + ticketCount +" 张票");
    
                   Thread.sleep(1000);
                   //System.out.println(Thread.currentThread().getName() + " 一共卖了" + count +"张");
               } catch (InterruptedException e) {
    e.printStackTrace();
               }
    
    }
    
    }

**其它方式：**

ExecutorService 线程池

Callable 实现接口Callable （有返回值且可以抛出异常）

Future 实现异步任务，Callable用来产生结果，Future用于获取结果。它们俩和线程池结合使用

**Thread和Runnable的区别**

Runnable方式可以避免Thread方式由于java单继承特性带来的缺陷

Runnable的代码、属性等可以被多个线程（多个Thread实例）共享

由于Thread也是实现Runnable的方式，适合用于多个线程处理**同一资源**的情况。

**线程守护启动**

通过调用Thread类的setDaemon(true)方法来设置当前线程为守护线程

\*必须在start()方法之前调用，否则会抛出IllegalThreadStartException（非法启动）异常

\*在守护线程中产生的新线程同样是守护线程

\*不要所有的线程都用守护线程执行，比如某些计算逻辑和简单的读写操作就不应该使用守护线程执行。因为用户线程全部失效了那么守护线程则和jvm直接终止了。如果这时候在守护线程里进行操作那么这些操作就直接退出了；

**线程调度**

1、**调整线程优先级**：Java线程有优先级，优先级高的线程会获得较多的运行机会。Thread类的setPriority()和getPriority()方法分别用来设置和获取线程的优先级。

2、**线程睡眠**：Thread.sleep(long millis)方法，使线程转到阻塞状态。millis参数设定睡眠的时间，以毫秒为单位。当睡眠结束后，就转为就绪（Runnable）状态。

3、**线程等待**：Object类中的wait()方法，导致当前的线程等待，直到其他线程调用此对象的 notify() 方法或 notifyAll() 唤醒方法。这个两个唤醒方法也是Object类中的方法，行为等价于调用 wait(0) 一样。

4、**线程让步**：Thread.yield() 方法，暂停当前正在执行的线程对象，把执行机会让给相同或者更高优先级的线程。

5、**线程加入**：join()方法，等待其他线程终止。在当前线程中调用另一个线程的join()方法，则当前线程转入阻塞状态，直到另一个进程运行结束，当前线程再由阻塞转为就绪状态。

6、**线程唤醒**：Object类中的notify()方法，唤醒在此对象监视器上等待的单个线程。如果所有线程都在此对象上等待，则会随机选择唤醒其中一个线程。

**线程其它常用方法：**

> sleep(): 强迫一个线程睡眠Ｎ毫秒（不释放锁）  
> isAlive(): 判断一个线程是否存活  
> join(): 等待线程终止  
> activeCount(): 程序中活跃的线程数  
> enumerate(): 枚举程序中的线程  
> currentThread(): 得到当前线程  
> isDaemon(): 一个线程是否为守护线程  
> setDaemon(): 设置一个线程为守护线程  
> (用户线程和守护线程的区别在于，是否等待主线程依赖于主线程结束而结束)  
> setName(): 为线程设置一个名称  
> wait(): 强迫一个线程等待（释放锁）  
> notify(): 通知一个线程继续运行  
> setPriority(): 设置一个线程的优先级

**线程安全—线程同步**

线程同步不是线程一起动作，而是协同步调，按预定的先后次序进行运行。比如你操作完我再操作。

比如进程或线程A和B一块配合，A执行到一定程度时要依靠B的某个结果，于是停下来，示意B运行；B依言执行，再将结果给A；A再继续操作；

线程同步目的是为了保护多个线程访问一个资源时对资源的破坏。

> 线程安全是并发编程重要的关注点，造成线程安全问题的主要诱因有两点:  
> 一是存在共享数据(也称临界资源)；  
> 二是存在多条线程共同操作共享数据。

因此我们就需要一个方案来解决多个线程操作同一个资源的方案——线程同步。

线程同步是通过锁（修饰符synchronized）来实现，每个对象都有且仅有一个锁，这个锁与一个特定的对象关联，线程一旦获取了对象锁，其他访问该对象的线程就无法再访问该对象的其他非同步方法。这种方式叫做互斥锁，也就是说当一个共享数据被当前正在访问的线程加上互斥锁后，在同一个时刻，其他线程只能处于等待的状态，直到当前线程处理完毕释放该锁。

**死锁**

死锁是指两个或两个以上的进程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程。拿前面的例子来说，如果线程A锁住了记录1并等待记录2，而线程B锁住了记录2并等待记录1，这样两个线程就发生了死锁现象。

使用synchronized修饰，测试锁：

@Override
       public synchronized void run() {
    int count = 0;
           while (ticketCount > 0){
    try {
    //买票
                   ticketCount -- ;
                   count ++;
                   //获取当前线程
                   System.out.println(Thread.currentThread().getName() + "卖了1张，还剩 " + ticketCount +" 张票");
    
                   Thread.sleep(1000);
                   //System.out.println(Thread.currentThread().getName() + " 一共卖了" + count +"张");
               } catch (InterruptedException e) {
    e.printStackTrace();
               }
    
           }
    
    //        synchronized (this){
    //            while (ticketCount > 0){
    //                try{
    //                    //买票
    //                    ticketCount -- ;
    //                    count ++;
    //                    //获取当前线程
    //                    System.out.println(Thread.currentThread().getName() + "卖了1张，还剩 " + ticketCount +" 张票");
    //                    Thread.sleep(1000);
    //                    //System.out.println(Thread.currentThread().getName() + " 一共卖了" + count +"张");
    //
    //                }catch (InterruptedException e) {
    //                    e.printStackTrace();
    //                }
    //            }
    //        }
    
       }

只能当前线程完成后其它线程才会执行：

线程的生命周期  
![o_QQ_e6_88_aa_e5_9b_be20180819200053.png][]

创建——就绪——运行——阻塞——就绪——运行——终止

**创建状态**: new Thread()

**就绪状态**: start(),也就是初始状态。加入到了线程队列，等待获取CPU服务，具备运行条件，但是并不一定运行，只有获得cpu的服务以后才会运行

**运行状态**: run()处于线程队列中的线程获取到cpu的资源服务以后就会运行。

**阻塞状态**: Blocked, 受到阻塞事件的影响就会进入到阻塞状态。由于某种原因暂时让出了CPU资源，暂停自己执行，就会进入阻塞状态，比如使用sleep()方法。阻塞状态完成以后再次进入线程队列，也就是就绪状态

**终止状态**: 完成运行逻辑以后run()执行完毕，或者调用stop()方法线程就进入终止状态

**阻塞的情况**,分三种：

（一）、等待阻塞：运行的线程执行wait()方法，JVM会把该线程放入等待池中。(wait会释放持有的锁)

（二）、同步阻塞：运行的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放入锁池中。

（三）、其他阻塞：运行的线程执行sleep()或join()方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。（注意,sleep是不会释放持有的锁）

\#\#讨论环节  
Q：什么是互斥锁？  
A：就是同一资源同一时间只能被同一个线程访问，也就是说这个资源被加锁以后哪个线程获取了锁哪个线程就可以访问当前资源。其它线程访问资源的时候会等待前一个线程释放锁以后再去获取这个锁，也就是访问资源的资格。这个锁就是互斥锁；

Q：并行与并发是什么？  
A：  
并行：多个cpu实例或者多台机器同时执行一段处理逻辑，是真正的同时。  
并发：通过cpu调度算法，让用户看上去同时执行，实际上从cpu操作层面不是真正的同时。并发往往在场景中有公用的资源，那么针对这个公用的资源往往产生瓶颈，我们会用TPS或者QPS来反应这个系统的处理能力。

Q：为什么要线程等待  
A：已经退出的线程，其空间没有被释放，仍然在进程的地址空间，如果一个线程结束运行但没有被等待，那么它类似于僵尸进程，占用的资源在进程结束前都不会被回收，所以当一个线程运行完成后，我们应该等待回收资源。

[o_QQ_e6_88_aa_e5_9b_be20180819200053.png]: /images/20220516/87b3add21a914924bfee31e90bebb13b.png