Java多线程-完成Android开发中的某些需求

6,240 阅读5分钟

一 需求

子线程中开启一个主线程去获取某些数据,此时子线程要处理等待状态,获取成功之后继续执行子线程中之后的代码.

  • 问题:
    当开启主线程去获取数据的时候,子线程的代码也会顺序去执行,这样并不能等到主线程有结果的时候再去执行子线程中的代码.
  • 分析:
    先来分析一下,当在线程A中开启另外一个线程B的时候,线程A中的代码还是顺序执行线程B的代码也会执行.这样的话线程A中需要线程B中返回参数的方法就没办法正确执行.
  • 解决:
    这里就用到了线程的wiat() notify() 和 synchronized 关键字,先来看下解决方法.
    final  Object obj = new Object();
         new Thread(){
              @Override
              public void run() {
                  super.run();
                  //通过Handler创建一个主线程.
                  new Handler(getMainLooper()).post(new Runnable() {
                      @Override
                      public void run() {
                          synchronized (obj) {
                          //模拟主线程耗时操作
                              try {
                                  Thread.sleep(1000);
                              } catch (InterruptedException e) {
                                  e.printStackTrace();
                              }
                              str = "WangChao";
                              Log.e("CHAO", "run 2" + str);
                              obj.notify();
                          }
                      }
                  });
                  Log.e("CHAO","run 1");
                  synchronized (obj) {
                      try {
                          obj.wait();
                      } catch (InterruptedException e) {
                          e.printStackTrace();
                      }
                      //子线程需要主线程的返回参数
                      if (str != null) {
                          Log.e("CHAO", "run 3" + str);
                      }
                  }
              }
          }.start();
    运行可知先运行的是run 1 ,之后是主线程中的run 2 ,然后是子线程中的 run 3.这样就可以达到我们想要的结果.运行结果如下:
    com.example.wang.threaddemo E/CHAO: run 1
    com.example.wang.threaddemo E/CHAO: run 2WangChao
    com.example.wang.threaddemo E/CHAO: run 3WangChao

二 涉及的Java线程的知识点

  • synchronized关键字的用法
    被synchronized修饰的方法称为同步方法,默认的锁是当前对象.所谓同步方法是如果有一个线程正在访问该方法的时候,其他的方法调用到该方法的时候将进入等待的状态.当有多个同步方法的时候,一旦一个线程调用了其中的一个同步方法,便对当前对象加锁,其他的线程调用拥有同对象锁的其它同步方法时会处于等待的状态,等之前的线程释放掉对象锁之后继续执行.
    1.去修饰方法 : 对象锁默认是当前对象 this .

    public synchronized void method2(){
              Log.e("CHAO", "method2: " + Thread.currentThread().getName());
      }

    还可以这样写:

           public  void method2(){
                  synchronized (this) {
                      Log.e("CHAO", "method2: " + Thread.currentThread().getName());
                  }
              }

    2.同步语句块 : 可以自己去设置加锁的对象.

        synchronized (obj) {
                              try {
                                  Thread.sleep(1000);
                              } catch (InterruptedException e) {
                                  e.printStackTrace();
                              }
                              str = "WangChao";
                              Log.e("CHAO", "2" + str);
                              obj.notify();
                          }

    这里需要注意的是synchronized (obj) 里面的参数,也就是要给那个对象加锁.这个对象必须是唯一的切多个线程都能拿到这个对象.(再使用Stirng最为对象锁的时候一定要注意String的重新赋值,一旦赋值改对象就改变了不再是我们之前加锁的对象),通常可以自己去创建一个final 的 Object类去加锁,也可以使用this,Class对象等.

    3.同步静态方法啊: 加锁对象是当前的Class对象.

    public static synchronized void method1(){
              int count = 0;
              for (int i = 0; i < 120000; i++) {
                  count++;
              }
              Log.e("CHAO", "method1: " + Thread.currentThread().getName());
      }

    同不得静态方法再多线程中的调用和非静态的是一致的.

  • wait()
    首先wait()是属于Object类的方法,从源码给出的解释来看,wait()方法可以做到如下几点:
    (1)首先,调用了wait()之后会引起当前线程处于等待状状态。
    (2)其次,每个线程必须持有该对象的monitor(监视)。如果在当前线程中调 用wait()方法之后,该线程就会释放monitor的持有对象并让自己处于等 待状态。
    (3)如果想唤醒一个正在等待的线程,那么需要开启一个线程通过notify()或者notifyAll()方法去通知正在等待的线程获取monitor对象。如此,该线程即可打破等待的状态继续执行代码.

    注意: wait()方法要使用在synchronized修饰的方法里面要不然会报异常,并且是synchronized()加锁的那个对象调用该方法.异常如下:

      java.lang.IllegalMonitorStateException: object not locked by thread before wait()
  • notify() , nitifyAll()
    notify()是属于Object类的方法.notify唤醒一个在这个对象上等待的线程监控。如果有任何线程在等待这个对象,其中一个线程被选择被唤醒。这个选择是任意的,并且发生在执行的自由裁量。一个线程在一个对象上等待通过调用wait()等方法来监视。nitifyAll唤醒所有的再等待中的线程.

    注意:nitify唤醒的线程会在该线程的wiat之后继续执行,特别要注意的是调用wiat的同步语句块的对象锁要和nitify的同步语句块的对象锁是同一个,否则的话你是唤醒不了wait状态的.

    final  Object obj = new Object();
         new Thread(){
              @Override
              public void run() {
                  super.run();
                  new Handler(getMainLooper()).post(new Runnable() {
                      @Override
                      public void run() {
                      //注意这个加锁对象
                          synchronized (obj) {
                              try {
                                  Thread.sleep(1000);
                              } catch (InterruptedException e) {
                                  e.printStackTrace();
                              }
                              str = "WangChao";
                              Log.e("CHAO", "2" + str);
                              //注意唤醒方法的调用者
                              obj.notify();
                          }
                      }
                  });
                  Log.e("CHAO","run"+1);
                  //注意这个加锁对象
                  synchronized (obj) {
                      try {
                      //注意等待方法的调用者
                          obj.wait();
                      } catch (InterruptedException e) {
                          e.printStackTrace();
                      }
                      if (str != null) {
                          Log.e("CHAO", "3" + str);
                      }
                  }
              }
          }.start();
  • sleep()
    sleep()方法来自于Thread类,从源码给出的解释来看,sleep()方法可以做到如下几点:
    (1)首先,调用sleep()之后,会引起当前执行的线程进入暂时中断状态,也即睡眠状态。
    (2)其次,虽然当前线程进入了睡眠状态,但是依然持有monitor对象。
    (3)在中断完成之后,自动进入唤醒状态从而继续执行代码

总结

(1)在线程的运行过程中,调用该线程持有monitor对象的wait()方法时,该线程首先会进入等待状态,并将自己持有的monitor对象释放。
(2)如果一个线程正处于等待状态时,那么唤醒它的办法就是开启一个新的线程,通过notify()或者notifyAll()的方式去唤醒。当然,需要注意的一点就是,必须是同一个monitor对象。
(3)sleep()方法虽然会使线程中断,但是不会将自己的monitor对象释放,在中断结束后,依然能够保持代码继续执行。

欢迎大家的点评和补充,喜欢的话就给个赞👍支持下吧~