Java多线程

最新推荐文章于 2024-03-20 10:15:00 发布

Gray.z

最新推荐文章于 2024-03-20 10:15:00 发布

阅读量102

点赞数 1

分类专栏： java 基础

本文链接：https://blog.csdn.net/zrg523/article/details/93892131

版权

java 基础专栏收录该内容

8 篇文章 0 订阅

订阅专栏

线程的定义：https://docs.oracle.com/javase/1.5.0/docs/api/java/lang/Thread.html

java 中的三种线程实现方式

Runnable接口：实现Runnable 接口具有更好的扩展性，通常，建议通过“Runnable”实现多线程！
Callable接口：允许得到线程返回值，通过FutrueTask<?> 类的get方法获取。
继承Thread：本身是实现了Runnable接口的类，存在单继承限制

//继承Thread  
class PrimeThread extends Thread {
         long minPrime;
         PrimeThread(long minPrime) {
             this.minPrime = minPrime;
         }
 
         public void run() {
             // compute primes larger than minPrime
              . . .
         }
     }
 
     //The following code would then create a thread and start it running:
     PrimeThread p = new PrimeThread(143);
     p.start();

 //实现Runnable
 class PrimeRun implements Runnable {
         long minPrime;
         PrimeRun(long minPrime) {
             this.minPrime = minPrime;
         }
 
         public void run() {
             // compute primes larger than minPrime
              . . .
         }
     }
 
     //The following code would then create a thread and start it running:
     PrimeRun p = new PrimeRun(143);
     new Thread(p).start();

java 中多线程的状态（https://docs.oracle.com/javase/1.5.0/docs/api/java/lang/Thread.State.html）：

NEW(新建/初始)：新创建了一个线程对象，但还没有调用start()方法。该线程还没有开始运行。这意味着它的状态是new。当一个线程处在new状态，程序还没有开始运行线程中的代码。在线程运行之前还有一些基础工作要做。
RUNNABLE(可运行)：线程对象创建后，其他线程调用了该对象的start()方法。该状态的线程位于可运行线程池中，变得可运行，等待获取CPU的使用权。可运行的线程可能正在运行也可能没有运行，这取决于操作系统给线程提供运行的时间(这就是为什么这个状态成为可运行而不是运行)；Java线程中将就绪（ready）和运行中（running）两种状态笼统的成为“运行”。线程对象创建后，其他线程(比如main线程）调用了该对象的start()方法。该状态的线程位于可运行线程池中，等待被线程调度选中，获取cpu 的使用权，此时处于就绪状态（ready）。就绪状态的线程在获得cpu 时间片后变为运行中状态。
BLOCKED（阻塞）：阻塞状态是线程因为某种原因放弃CPU使用权，暂时停止运行。直到线程进入就绪状态，才有机会转到运行状态；线程在Running的过程中可能会遇到阻塞(Blocked)的情况分三种：

等待阻塞：运行的线程执行wait()方法，JVM会把该线程放入等待池(wait blocked pool)中，直到notify()/notifyAll()，线程被唤醒被放到锁定池(lock blocked pool )，释放同步锁使线程回到可运行状态（Runnable）。
同步阻塞：运行的线程在获取对象的同步锁(synchronized)时，若该同步锁被别的线程占用，则JVM会把该线程放入锁池(lock blocked pool )中，同步锁被释放进入可运行状态(Runnable)。
其他阻塞：运行的线程执行sleep()或join()方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。

WAITING（等待）：进入该状态的线程需要等待其他线程做出一些特定动作（通知或中断）,处于这种状态的线程不会被分配CPU执行时间，它们要等待被显式地唤醒，否则会处于无限期等待的状态。
TIMED_WAITING(超时等待)：该状态不同于WAITING，它可以在指定的时间内自行返回。处于这种状态的线程不会被分配CPU执行时间，不过无须无限期等待被其他线程显示地唤醒，在达到一定时间后它们会自动唤醒。
TERMINATED（结束/死亡）：表示该线程已经执行完毕。当线程的run()方法完成时，或者主线程的main()方法完成时，我们就认为它终止了。这个线程对象也许是活的，但是，它已经不是一个单独执行的线程。线程一旦终止了，就不能复生

以上6种状态涉及到的内容包括Object类, Thread和synchronized关键字。
Object类：定义了wait(), notify(), notifyAll()等休眠/唤醒函数。
Thread类：定义了一些列的线程操作函数。例如，sleep()休眠函数, interrupt()中断函数, getName()获取线程名称等。
synchronized关键字；它区分为synchronized代码块和synchronized方法。synchronized的作用是让线程获取对象的同步锁。

线程的状态图

çº¿ç¨ç¶æå¾

Thread类主要方法说明：

yield()方法：作用是让步，将线程从运行running状态转到可运行runnable状态,从而让其它具有相同优先级的等待线程获取执行权；但是，并不能保证在当前线程调用yield()之后，其它具有相同优先级的线程就一定能获得执行权；也有可能是当前线程又进入到“运行状态”继续运行！yield()方法不会释放对象锁！

join()方法：让“主线程”等待“子线程”结束之后才能继续运行，将等待其他子线程执行完后才继续主线程，底层调用了Object 的wait()，wait()方法的作用让“当前线程”等待，而这里的“当前线程”是指当前在CPU上运行的线程。

start()方法：它的作用是启动一个新线程，新线程会执行相应的run()方法。start()不能被重复调用

run()方法：和普通的成员方法一样，可以被重复调用。单独调用run()的话，会在当前线程中执行run()，而并不会启动新线程！

interrupt()的作用是中断本线程。本线程中断自己是被允许的；其它线程调用本线程的interrupt()方法时，会通过checkAccess()检查权限。这有可能抛出SecurityException异常，被打断的线程会抛出InterruptedException

interrupted() 和 isInterrupted():都能够用于检测对象的“中断标记”。区别是，interrupted()除了返回中断标记之外，它还会清除中断标记(即将中断标记设为false)；而isInterrupted()仅仅返回中断标记。

线程等待与唤醒

在Object.java中，定义了wait(), notify()和notifyAll()等接口。wait()的作用是让当前线程进入等待状态，同时，wait()也会让当前线程释放它所持有的锁。而notify()和notifyAll()的作用，则是唤醒当前对象上的等待线程；notify()是唤醒单个线程，而notifyAll()是唤醒所有的线程。

Object类中关于等待/唤醒的API详细信息如下：
notify() :唤醒在此对象监视器上等待的单个线程。
notifyAll():唤醒在此对象监视器上等待的所有线程。
wait():让当前线程处于“等待(阻塞)状态”，“直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法”，当前线程被唤醒(进入“就绪状态”);线程调用wait()之后，会释放它锁持有的“同步锁”，notify()是依据什么唤醒等待线程的？或者说，wait()等待线程和notify()之间是通过什么关联起来的？答案是：依据“对象的同步锁”。负责唤醒等待线程的那个线程(我们称为“唤醒线程”)，它只有在获取“该对象的同步锁”(这里的同步锁必须和等待线程的同步锁是同一个)，并且调用notify()或notifyAll()方法之后，才能唤醒等待线程。虽然，等待线程被唤醒；但是，它不能立刻执行，因为唤醒线程还持有“该对象的同步锁”。必须等到唤醒线程释放了“对象的同步锁”之后，等待线程才能获取到“对象的同步锁”进而继续运行。总之，notify(), wait()依赖于“同步锁”，而“同步锁”是对象锁持有，并且每个对象有且仅有一个！这就是为什么notify(), wait()等函数定义在Object类，而不是Thread类中的原因。
wait(long timeout) :让当前线程处于“等待(阻塞)状态”，“直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或者超过指定的时间量”，当前线程被唤醒(进入“就绪状态”)。
wait(long timeout, int nanos) :让当前线程处于“等待(阻塞)状态”，“直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或者其他某个线程中断当前线程，或者已超过某个实际时间量”，当前线程被唤醒(进入“就绪状态”)。

在java中，每一个对象有且仅有一个同步锁。这也意味着，同步锁是依赖于对象而存在。当我们调用某对象的synchronized方法时，就获取了该对象的同步锁。例如，synchronized(obj)就获取了“obj这个对象”的同步锁。不同线程对同步锁的访问是互斥的。Object中的wait(), notify()等函数，和synchronized一样，会对“对象的同步锁”进行操作。synchronized, wait, notify 是任何obj对象都具有的同步工具，调用obj的wait(), notify()方法前，必须获得obj锁，也就是必须写在synchronized(obj) 代码段内。

monitor监视器是应用于同步问题的人工线程调度工具。讲其本质，首先就要明确monitor的概念，Java中的每个对象都有一个监视器，来监测并发代码的重入。在非多线程编码时该监视器不发挥作用，反之如果在synchronized 范围内，监视器发挥作用。

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

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

synchronized(内置锁、对象锁)单独使用：

代码块：如下，在多线程环境下，synchronized块中的方法获取了obj实例的monitor，如果实例相同，那么只有一个线程能执行该块内容

public class Thread1 implements Runnable {
   Object obj;
   public void run() {  
       synchronized(obj){
         ..do something
       }
   }
}

直接用于方法：相当于上面代码中用obj来锁定的效果，实际获取的是Thread1类的monitor。更进一步，如果修饰的是static方法，则锁定该类所有实例。

public class Thread1 implements Runnable {
   public synchronized void run() {  
        ..do something
   }
}

synchronized, wait, notify结合:典型场景生产者消费者问题

int product =0;
/**
   * 生产者生产出来的产品交给店员
   */
  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会牺牲性能。

同步队列状态

当前线程想调用对象A的同步方法时，发现对象A的锁被别的线程占有，此时当前线程进入同步队列。简言之，同步队列里面放的都是想争夺对象锁的线程。
当一个线程1被另外一个线程2唤醒时，1线程进入同步队列，去争夺对象锁。
同步队列是在同步的环境下才有的概念，一个对象对应一个同步队列。
线程等待时间到了或被notify/notifyAll唤醒后，会进入同步队列竞争锁，如果获得锁，进入RUNNABLE状态，否则进入BLOCKED状态等待获取锁。

Gray.z

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java多线程

线程的定义：https://docs.oracle.com/javase/1.5.0/docs/api/java/lang/Thread.htmljava 中的三种线程实现方式Runnable接口：实现Runnable 接口具有更好的扩展性，通常，建议通过“Runnable”实现多线程！ Callable接口：允许得到线程返回值，通过FutrueTask<?> 类的get方...
复制链接

扫一扫