多线程

Posted zkkkk-

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了多线程相关的知识,希望对你有一定的参考价值。

一,什么是多线程?

进程:一个正在执行的程序,比如说微信

线程:进程中的一个独立控制单元,线程控制着进程的执行

并行与并发:

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

二,为什么使用多线程编程?

    ①、为了更好的利用cpu的资源,如果只有一个线程,则第二个任务必须等到第一个任务结束后才能进行,如果使用多线程则在主线程执行任务的同时可以执行其他任务,而不需要等待;

    ②、进程之间不能共享数据,线程可以;

    ③、系统创建进程需要为该进程重新分配系统资源,创建线程代价比较小;

    ④、Java语言内置了多线程功能支持,简化了java多线程编程。

三,线程的生命周期?

技术图片

  • 新建 :从新建一个线程对象到程序start() 这个线程之间的状态,都是新建状态;
  • 就绪 :线程对象调用start()方法后,就处于就绪状态,等到JVM里的线程调度器的调度;
  • 运行 :就绪状态下的线程在获取CPU资源后就可以执行run(),此时的线程便处于运行状态,运行状态的线程可变为就绪、阻塞及死亡三种状态。
  • 等待/阻塞/睡眠 :在一个线程执行了sleep(不会释放锁)(睡眠)、suspend(挂起)等方法后会失去所占有的资源,从而进入阻塞状态,在睡眠结束后可重新进入就绪状态。
    • 等待阻塞:运行状态中的线程执行 wait() 方法,使线程进入到等待阻塞状态,释放锁,调用wait(),使该线程处于等待池(wait blocked pool),直到notify()/notifyAll(),线程被唤醒被放到锁定池(lock blocked pool ),使线程回到可运行状态(Runnable)

    • 同步阻塞:线程在获取 synchronized 同步锁失败(因为同步锁被其他线程占用)。

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

  • 终止 :run()方法完成后或发生其他终止条件时就会切换到终止状态。

 monitor

java中的每个对象都有一个监视器,来监测并发代码的重入。在非多线程编码时该监视器不发挥作用,反之如果在synchronized 范围内,监视器发挥作用。

 

wait/notify必须存在于synchronized块中。并且,这三个关键字针对的是同一个监视器(某对象的监视器)。这意味着wait之后,其他线程可以进入同步块执行。

 

当某代码并不持有监视器的使用权时(如图中5的状态,即脱离同步块)去wait或notify,会抛出java.lang.IllegalMonitorStateException。也包括在synchronized块中去调用另一个对象的wait/notify,因为不同对象的监视器不同,同样会抛出此异常。

 

用法:

synchronized单独使用:

  • 代码块:如下,在多线程环境下,synchronized块中的方法获取了lock实例的monitor,如果实例相同,那么只有一个线程能执行该块内容
  • public class Thread1 implements Runnable {
       Object lock;
       public void run() {  
           synchronized(lock){
             ..do something
           }
       }
    }

     

  • 直接用于方法: 相当于上面代码中用lock来锁定的效果,实际获取的是Thread1类的monitor。更进一步,如果修饰的是static方法,则锁定该类所有实例。
  • public class Thread1 implements Runnable {
       public synchronized void run() {  
            ..do something
       }
    }

     

  • synchronized, wait, notify结合:典型场景生产者消费者问题
  • /**
       * 生产者生产出来的产品交给店员
       */
      public synchronized void produce()
      {
          if(this.product >= MAX_PRODUCT)
          {
              try
              {
                  wait();  
                  System.out.println("产品已满,请稍候再生产");
              }
              catch(InterruptedException e)
              {
                  e.printStackTrace();
              }
              return;
          }
    
          this.product++;
          System.out.println("生产者生产第" + this.product + "个产品.");
          notifyAll();   //通知等待区的消费者可以取出产品了
      }
    
      /**
       * 消费者从店员取产品
       */
      public synchronized void consume()
      {
          if(this.product <= MIN_PRODUCT)
          {
              try 
              {
                  wait(); 
                  System.out.println("缺货,稍候再取");
              } 
              catch (InterruptedException e) 
              {
                  e.printStackTrace();
              }
              return;
          }
    
          System.out.println("消费者取走了第" + this.product + "个产品.");
          this.product--;
          notifyAll();   //通知等待去的生产者可以生产产品了
      }

     

    volatile

    多线程的内存模型:main memory(主存)、working memory(线程栈),在处理数据时,线程会把值从主存load到本地栈,完成操作后再save回去(volatile关键词的作用:每次针对该变量的操作都激发一次load and save)。

  • 针对多线程使用的变量如果不是volatile或者final修饰的,很有可能产生不可预知的结果(另一个线程修改了这个值,但是之后在某线程看到的是修改之前的值)。其实道理上讲同一实例的同一属性本身只有一个副本。但是多线程是会缓存值的或者网络延迟,本质上,volatile就是不去缓存,直接取值。在线程安全的情况下加volatile会牺牲性能

 

四,创建线程

1、继承Thread类:

    步骤:①、定义类继承Thread;

     ②、复写Thread类中的run方法;
    目的:将自定义代码存储在run方法,让线程运行
     ③、调用线程的start方法:
    该方法有两步:启动线程,调用run方法。
public class ThreadDemo1 {

    public static void main(String[] args) {
        
        //创建两个线程
        ThreadDemo td = new ThreadDemo("zhangsan");
        ThreadDemo tt = new ThreadDemo("lisi");
        //执行多线程特有方法,如果使用td.run();也会执行,但会以单线程方式执行。
        td.start();
        tt.start();
        //主线程
        for (int i = 0; i < 5; i++) {
            System.out.println("main" + ":run" + i);
        }
    }
}
//继承Thread类
class ThreadDemo extends Thread{
    
    //设置线程名称
    ThreadDemo(String name){
        super(name);
    }
    //重写run方法。
    public void run(){
        for(int i = 0; i < 5; i++){
        System.out.println(this.getName() + ":run" + i);  //currentThread()  获取当前线程对象(静态)。  getName() 获取线程名称。
        }
    }
}

 

2、实现Runnable接口: 接口应该由那些打算通过某一线程执行其实例的类来实现。类必须定义一个称为run 的无参方法。

     实现步骤:  ①、定义类实现Runnable接口

          ②、覆盖Runnable接口中的run方法

             将线程要运行的代码放在该run方法中。

          ③、通过Thread类建立线程对象。

          ④、将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数。

             自定义的run方法所属的对象是Runnable接口的子类对象。所以要让线程执行指定对象的run方法就要先明确run方法所属对象

          ⑤、调用Thread类的start方法开启线程并调用Runnable接口子类的run方法。

public class RunnableDemo {
    public static void main(String[] args) {
        RunTest rt = new RunTest();
        //建立线程对象
        Thread t1 = new Thread(rt);
        Thread t2 = new Thread(rt);
        //开启线程并调用run方法。
        t1.start();
        t2.start();
    }
}

//定义类实现Runnable接口
class RunTest implements Runnable{
    private int tick = 10;
    //覆盖Runnable接口中的run方法,并将线程要运行的代码放在该run方法中。
    public void run(){
        while (true) {
            if(tick > 0){
                System.out.println(Thread.currentThread().getName() + "..." + tick--);
            }
        }
    }
}

 

两种方法对比:

继承Thread:线程代码存放在Thread子类run方法中。

        优势:编写简单,可直接用this.getname()获取当前线程,不必使用Thread.currentThread()方法。

        劣势:已经继承了Thread类,无法再继承其他类。

    实现Runnable:线程代码存放在接口的子类的run方法中。

        优势:避免了单继承的局限性、多个线程可以共享一个target对象,非常适合多线程处理同一份资源的情形。

        劣势:比较复杂、访问线程必须使用Thread.currentThread()方法、无返回值。

,常用API

currentThread()     获取当前线程,如果在main方法中,则获取的是main,而不是被start()调用的方法

isAlive()   判断当前线程是否处于活跃状态,线程处于正在运行状态,或者准备开始运行的状态,都认为是活跃状态

sleep()   让当前正在执行的

 yield() 该方法和sleep方法类似,也是Thread类提供的一个静态方法,可以让正在执行的线程暂停,但是不会进入阻塞状态,而是直接进入就绪状态。

interrupt() 虚拟机会在此线程上标记一个标志(这个中断标志只是一个布尔类型的变量),代表这个线程可能被中断,在后面的中断操作也是根据这个中断标志执行的,如果一个线程被标记了中断标识(调用                            interrupt方法),然后调用sleep,wait,jion,io操作等,进入阻塞状态时,会抛出InterruptedException异常,然后清除标识位的中断标记

interrupted():测试当前线程是否中断。 该方法可以清除线程的中断状态 。

isInterrupted():测试这个线程是否被中断。线程的中断状态不受此方法的影响。

六,线程间通信

wait()

  • wait( )     使当前线程执行代码的线程进行等待,wait()方法时object类的方法,在wait()所在代码行处停止运行,直到接到通知或中断为止。在调用wait()方法之前,线程必须获得该对象的对象级别锁,即只能在同步方法或同步块中调用此方法,在调用wait()方法后,线程释放锁。在wait()方法返回前,线程与其他线程竞争重新获取锁,如果调用wait()方法时,没有持有适当的锁,,则抛出IllegalMonitorStateException异常
  • 线程呈wait()状态时,调用线程对象的interrupt()方法会出现InturreputException异常
  • 当多个执行 相同任务的线程,条件判断时wait(),用while(),不能用if,  当线程wait后,又被唤醒时,是从wait后main开始执行,如果用if,就不会执行条件判断了

 notify()

notify()也必须在同步方法或同步块中调用,即在调用前,线程必须获取该对象的级别锁,该方法用于唤醒处于wait状态的线程,此方法执行后,不会释放锁,只有在在notify所在方法块执行完才会释放锁

 

join()

B线程执行到了A线程的.join()方法时,B线程就会等待,等A线程都执行完毕,B线程才会执行。

 

 两个队列:

就绪队列

  • 存储即将获得锁的线程
  • 被notify并且拿到锁的线程

 阻塞队列:

  • 被阻塞的线程
  • 调用wait的线程

七,Lock类

 

lock: 在java.util.concurrent包内。共有三个实现:

ReentrantLock
ReentrantReadWriteLock.ReadLock
ReentrantReadWriteLock.WriteLock

主要目的是和synchronized一样, 两者都是为了解决同步问题,处理资源争端而产生的技术。功能类似但有一些区别。

ReentrantLock的用法

Lock类的用法也是这样,通过Lock对象lock,用lock.lock来加锁,用lock.unlock来释放锁。在两者中间放置需要同步处理的代码。

public class MyConditionService {

    private Lock lock = new ReentrantLock();
    public void testMethod(){
        lock.lock();
        for (int i = 0 ;i < 5;i++){
            System.out.println("ThreadName = " + Thread.currentThread().getName() + (" " + (i + 1)));
        }
        lock.unlock();
    }
}

 

 Condition的用法:

Condition是Java提供了来实现等待/通知的类,Condition类还提供比wait/notify更丰富的功能,Condition对象是由lock对象所创建的,但是同一个锁可以创建多个Condition的对象,即创建多个对象监视器。这样的好处就是可以指定唤醒线程。notify唤醒的线程是随机唤醒一个。

下面,看一个例子,显示简单的等待/通知

public class ConditionWaitNotifyService {

    private Lock lock = new ReentrantLock();//创建锁
    public Condition condition = lock.newCondition();//创建condition实例


    public void await(){
        try{
            lock.lock();//开启锁
            System.out.println("await的时间为 " + System.currentTimeMillis());
            condition.await();
            System.out.println("await结束的时间" + System.currentTimeMillis());
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();//释放锁
        }
    }


    public void signal(){
        try{
            lock.lock();
            System.out.println("sign的时间为" + System.currentTimeMillis());
            condition.signal();
        }finally {
            lock.unlock();
        }
    }
}

 

  • condition对象通过lock.newCondition()来创建,用condition.await()来实现让线程等待,是线程进入阻塞。
  • condition.signal()来实现唤醒线程。唤醒的线程是用同一个conditon对象调用await()方法而进入阻塞。
  • await()和signal()也是在同步代码区内执行。

 

 

 

 

以上是关于多线程的主要内容,如果未能解决你的问题,请参考以下文章

线程学习知识点总结

多个请求是多线程吗

python小白学习记录 多线程爬取ts片段

多线程编程

多线程编程

python多线程