Android中线程Thread的使用

已于 2023-10-14 17:49:23 修改
阅读量6.1k 收藏 12
点赞数 2
分类专栏： Android入门与基础 文章标签： 多线程 android CountDownLatch CopyOnWriteArrayList Atomic
于 2017-03-06 21:20:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lyz_zyx/article/details/60598656
版权

1 定义

主线程是指进程拥有的线程，或叫UI线程，Java中默认情况下一个进程只有一个线程，这个线程就是主线程。主线程不能执行耗时的任务,所以在一些耗时处理时，就得使用子线程。Android沿用了Java的线程模型，从Android3.0开始系统要求网络访问也必须在子线程中进行，否则网络访问将会失败并抛出NetworkOnMainThreadException异常。在Android里如果主线程被执行耗时任务导致阻塞后还会造成ANR的发生。

2 线程五个基本状态

新建状态（New）线程对象创建后就会进入了新建状态，如：Thread t = new MyThread();

就绪状态（Runnable）当调用线程对象的start()方法后，如：t.start();，线程进入就绪状态。此状态的线程只是明确做好了准备，随时等待CPU调度执行，并未开始执行

运行状态（Running）当CPU开始调度处于就绪状态的线程时，此时线程才得以真正执行，即进入到运行状态。

阻塞状态（Blocked）处于运行状态中的线程由于某种原因，暂时放弃对CPU的使用权，停止执行，此时进入阻塞状态，阻塞状态后要再到运行状态，必须是先经过就绪状态。

死亡状态（Dead）线程执行完了或者因异常退出了run()方法，该线程结束生命周期

3 线程的阻塞情况

等待阻塞：运行状态中的线程执行一个对象wait()方法挂起线程时，使本线程进入到等待阻塞状态，直到其他线程执行notify()或者notifyAll()方法。

同步阻塞：线程执行一段同步代码，但尚无法获得相关同步锁，例如获取synchronized同步锁失败(因为锁被其它线程所占用)，那么线程会进入同步阻塞状态，直到等到获取同步锁。

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

4 多线程的使用

Java中主要提供两种方式实现线程，分别为继承java.lang.Thread类与实现java.lang.Runnable接口。

4.1 继承Thread类

class MyThread extends Thread {
    @Override
    public void run() {
        //TODO...
    }
}

// 调用使用线程
Thread myThread = new MyThread();              // 新建状态
myThread.start();                              // 就绪状态

4.2 实现Runable接口

class MyRunnable implements Runnable {
    @Override
    public void run() {
        //TODO...
    }
}
// 调用使用线程  
Runnable myRunnable = new MyRunnable();         // 创建Runable类对象  
Thread thread = new Thread(myRunnable);         // 将Runnable对象作为Thread target创建新的线程  
thread.start();

4.3 同时使用继承Thread的类和实现Runnable接口的类

Runnable myRunnable = new MyRunnable();
Thread myThread = new MyThread(myRunnable);
myThread.start();

这种方式也能创建一个新的线程。但是，此线程执行到底是MyRunnable接口中的run方法还是MyThread类中的run方法呢？答案是：MyThread类中的run()方法。因为Thread类本身也实现了Runnable接口，而重写Runnable的run方法的。Thread源码大概是这样：

public class Thread implements Runnable {  
     ……
    @Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }  
 ……
}

从源码可以看到，当执行到Thread类中的run()方法时，会首先判断target是否存在，存在则执行target中的run()方法，也就是实现了Runnable接口并重写了run()方法的类中的run()方法。但是上述情况，由于多态的存在，即MyThread中run()方法重写了父类的run()方法，所以根本就没有执行到Thread类中的run()方法，而是直接先执行了MyThread类中的run()方法。

5 操作线程的方法

5.1 线程的休眠(sleep)

使用sleep()方法时，必须加入InterruptedException异常捕捉，使用sleep()方法的会使线程进入睡觉状态，也就是上面提到的阻塞状态，接收的参数是毫秒，在设定的毫秒时间内醒来后，它并不能保证能进入运行状态，只能保证它进入就绪状态。使用如下：

……
try {
    Thread.sleep(2000);
} catch (InterrupedException e) {
    e.printStackTrace();
}
……

5.2 线程的中断(interrup)

现在已经不提倡使用stop方法来停止线程，因为那是不安全的，最好的停止线程方式是定义一个类成员变量，然后在循环过程中去判断此变量是否为假，便退出当前循环。但如果线程正在sleep()或wait()中，便无法使用类成员变量来判断，此时可以使用interrup()方法离开run()方法，同时结束线程，但程序会抛出InterruptedException异常。使用如下：

class MyThread extends Thread {
    volatile boolean mStop = false;         //volatile修饰变量一种轻量级的同步机制
    @Override
    public void run() {
        while (!Thread.currentThread().isInterrupted() && !mStop) {
            try {
                Thread.sleep(1000);
                // TODO...
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

// 启动线程
MyThread myThread = new MyThread();
myThread.start();
// 停止线程
myThread.mStop = true;
myThread.interrupt();

 Java提供了中断机制，Thread类下有三个重要方法：

  1. public void interrupt()方法可用于外部或者线程内部进行中断标记，它不会真正中断正在运行的线程，只是发出一个请求，由线程在合适的时候结束自己。如果存在sleep则会抛出InterruptedException异常。
  2. public boolean isInterrupted()方法用于判断中断标记是否为true。
  3. public static boolean interrupted()方法用于清除中断标志，并返回原状态。

5.3 线程的加入(join)

假如存在线程A和线程B，线程A正在运行状态，而现在要求线程A先暂停，让线程B先执行完毕，然后再继续执行线程A，此时就应使用join()方法来完成。这就好比你正在看电视，却突然有人上门送快递，那么您就先开门签收快递后再继续看电视一样。使用如下：

Thread t = new Thread(new Runnable() {
    @Override
    public void run() {
        try {
            Thread.sleep(1000);
            System.out.println("[" + Thread.currentThread().getName() + "] Hello...");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
});
t.start();
try {
    t.join();
} catch (Exception e) {
    e.printStackTrace();
}
System.out.println("[" + Thread.currentThread().getName() + "] Hello...");

输出结果是：

[Thread-0] Hello...
[main] Hello...

5.4 线程礼让(yield)

yield()方法使当前线程让出CPU占有权，使正在运行中的线程重新变成就绪状态，并重新竞争 CPU 的调度权。那么同样优先级的线程就有了可执行状态的机会。对于支持多任务的操作系统来说，不需要调用yeild()方法，因为操作系统会为线程自动分配CPU时间片来执行。

另外要注意的是，yield并不会释放锁标志。

Runnable runnable = new Runnable() {
    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {
            System.out.println("[" + Thread.currentThread().getName() + "] Hello..." + i);
            if (i % 20 == 0) {
                Thread.yield();
            }
        }
    }
};

new Thread(runnable, "thread1").start();
new Thread(runnable, "thread2").start();

6 线程的优先级

Thrread类中包含的成员变量代表了线程的某些优先级，比如Thread.MIN_PRIORITY（常数1）、Thread.NORM_PRIORITY（常数5）、Thread.MAX_PRIORITY（常数10）。其中每个线程的优先级都在Thread.MIN_PRIORITY ~ Thread.MAX_PRIORITY之间，值越大优化级越高，默认是Thread.NORM_PRIORITY。

线程的优先级可使用setPriority()方法调整，如果使用该方法设置的优先级不在1~10之内，将产生IllegalArgumentException异常。

7 线程安全/线程同步

单一程序中每次只能做一件事情，它是串行执行的；但多线程程序是可以异步并发处理同一件事情，这样就会发生两个线程抢占资源的问题，使如一个线程正在写数据，而另一个线程刚才在读数据，那么就会产生很多未知的错误情况出现，这也是多线程最危险的事情。

7.1同步锁synchronized

synchronized表示一个同步锁，是多线程中最常用的锁。它使在多个线程本来异步并发时变成了同步执行，也就是说在那一时刻只能一个线程获取同步锁，未获得的线程的状态会变成同步阻塞状态，直到等到获取同步锁。它可以用于修饰方法或代码块，当它用于方法时，synchronized关键字是不能继承的，所以同样在接口中的方法是不能使用synchronized，以及构造方法不能使用synchronized，但可以使用synchronized代码块。

7.1.1 修饰一个的方法

当synchronized修饰一个方法时，其作用的范围是整个方法，作用的对象是调用这个方法的对象。

Runnable runnable = new Runnable() {
    @Override
    public void run() {
        if (Thread.currentThread().getName().equalsIgnoreCase("thread1")) {
            funA();
        } else if (Thread.currentThread().getName().equalsIgnoreCase("thread2")) {
            funB();
        } else {
            funC();
        }
    }

    private synchronized void funA() {
        for (int i = 0; i < 5; i++) {
            try {
                System.out.println("[" + Thread.currentThread().getName() + "] funA " + i);
                Thread.sleep(500);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    private synchronized void funB() {
        for (int i = 0; i < 5; i++) {
            try {
                System.out.println("[" + Thread.currentThread().getName() + "] funB " + i);
                Thread.sleep(500);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    private void funC() {
        for (int i = 0; i < 5; i++) {
            try {
                System.out.println("[" + Thread.currentThread().getName() + "] funC " + i);
                Thread.sleep(500);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
};
new Thread(runnable, "thread1").start();
new Thread(runnable, "thread2").start();
new Thread(runnable, "thread3").start();

输出结果：

[thread3] funC 0
[thread1] funA 0
[thread1] funA 1
[thread3] funC 1
[thread3] funC 2
[thread1] funA 2
[thread3] funC 3
[thread1] funA 3
[thread3] funC 4
[thread1] funA 4
[thread2] funB 0
[thread2] funB 1
[thread2] funB 2
[thread2] funB 3
[thread2] funB 4

解说：

  1. thread3线程去执行的funC并没有同步锁，所以它不受锁控制。
  2. thread1和thread2因为它们是同步方法，所以同一时间只有一个线程在执行，而另一个线程在排队。

7.1.2 修饰一块代码，锁定一个对象

锁是有性能的代价的，有时候我们并不需要对整个方法进行锁，而仅仅是方法内的了某部分代码，那么就可以使用 synchronized 来修饰一块代码。

当synchronized修饰一块代码时，其作用的范围是大括号括起来的代码块，作用对象便是synchronized中传入的锁定对象。

7.1.2.1 synchronized(this)

如果将上述示例中 private void funA() {…} 和 private void funB() {…} 变换成以下的形式，其效果是等价的。

private void funA() {
    synchronized (this) {
        // ……
    }
}
private void funB() {
    synchronized (this) {
        // ……
    }
}

7.1.2.3 synchronized(object)

其实this也是一个object的一种，但是有时往往我们仅仅需要锁定某个变量而并非需要锁定当前整个this。因为有时候可能存在funA方法和funB方法针对某个对象需要同步执行，而funC方法和funD方法又针对另一个对象需要同步，但如果全用this的话就会造成4个方法都同步执行了。这明显不是我们想要的。

Runnable runnable = new Runnable() {
    List<Integer> list = new ArrayList();

    @Override
    public void run() {
        if (Thread.currentThread().getName().equalsIgnoreCase("thread1")) {
            funA();
        } else if (Thread.currentThread().getName().equalsIgnoreCase("thread2")) {
            funB();
        }
    }

    private void funA() {
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        synchronized (list) {
            int size = list.size();
            for (int i = 0; i < size; i++) {
                try {
                    System.out.println("[" + Thread.currentThread().getName() + "] funA " + list.get(i));
                    Thread.sleep(500);
                } catch (Exception e) {
                    e.printStackTrace();
                    break;
                }
            }
        }
    }

    private void funB() {
        synchronized (list) {
            list.clear();
            System.out.println("[" + Thread.currentThread().getName() + "] funB " + list.size());
        }
    }
};
new Thread(runnable, "thread1").start();

// thread2有意保证晚一点再运行
try {
    Thread.sleep(100);
} catch (Exception e) {
    e.printStackTrace();
}
new Thread(runnable, "thread2").start();

输出结果：

[thread1] funA 1
[thread1] funA 2
[thread1] funA 3
[thread1] funA 4
[thread1] funA 5
[thread2] funB 0

解说：

  1. thread2线程有意延迟了100毫秒执行，为了保证thread1先执行。
  2. 如果示例不加synchronized同步锁的话，在funA中的第二次循环中就会发生数组越界异常，因为list已经在funB中被清空了。
  3. 当没有一个明确的对象作锁时，但只想要两个代码块同步执行，可以创建一个特殊的对象来充当锁，如：private byte[] lock = new byte[0];

注意：

如果Integer或者Long这类装箱类型对象作锁时，且值在锁内会发生变化时，就会存在同步失败情况。因为它们内部值发生变化时会创建新的对象，而非原来锁住的对象。所以我们应该避免使用它们作为同步锁时的锁定对象。

7.1.3 修饰一个静态方法

当synchronized修饰一个静态方法时，其作用的范围是整个静态方法，作用的对象是这个类的所有对象。

class MyRunnable implements Runnable {
    @Override
    public void run() {
        if (Thread.currentThread().getName().equalsIgnoreCase("thread1")) {
            funA();
        } else if (Thread.currentThread().getName().equalsIgnoreCase("thread2")) {
            funB();
        }
    }

    private synchronized static void funA() {
        for (int i = 0; i < 5; i++) {
            try {
                System.out.println("[" + Thread.currentThread().getName() + "] funA " + i);
                Thread.sleep(500);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    private synchronized static void funB() {
        for (int i = 0; i < 5; i++) {
            try {
                System.out.println("[" + Thread.currentThread().getName() + "] funB " + i);
                Thread.sleep(500);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

new Thread(new MyRunnable(), "thread1").start();
new Thread(new MyRunnable(), "thread2").start();

输出结果：

[thread1] funA 0
[thread1] funA 1
[thread1] funA 2
[thread1] funA 3
[thread1] funA 4
[thread2] funB 0
[thread2] funB 1
[thread2] funB 2
[thread2] funB 3
[thread2] funB 4

解说：

尽管thread1和thread2中的MyRunable对象不同，但是它们同步锁的是静态方法，所以相当于它们用了同一把锁。

7.1.4 修饰一块静态代码，锁定一个类

也是同样的道理，因为锁是有性能的代价的，有时候我们并不需要对整个静态方法进行锁，而仅仅是静态方法内的了某部分代码，那么就可以使用 synchronized 来修饰一块静态代码。

当synchronized修饰一个静态方法里的一块代码时，其作用的范围是大括号括起来的代码块，作用对象是这个类的所有对象。

如果将上述示例中 private static void funA() {…} 和 private static void funB() {…} 变换成以下的形式，其效果是等价的。

private static void funA() {
    synchronized (MyRunnable.class) {
        // ……
    }
}
private static void funB() {
    synchronized (MyRunnable.class) {
        // ……
    }
}

 7.1.4 小结

无论synchronized 用于修饰方法还是代码块、静态代码还是非静态代码，主要区分其实就是它的作用范围和作用对象。在静态代码中，锁定的对象就是一个类，或者说是该类的所有对象。

  1. 哪个线程先获得这个锁，它就有运行它所控制锁在作用范围内的代码，其它线程处理同步阻塞状态。
  2. 实现同步是要很大的系统开销作为代价的，甚至可能造成死锁，所以尽量避免无谓的同步控制。

7.2 可重入锁ReentrantLock

ReentrantLock是一个继承于Lock接口的类，它同样可以像synchronized一样实现独占锁的功能。而且它的功能更加丰富，使用起来更加灵活，但是它需要手动加锁和手动解锁，在使用上要注意加锁解锁的次数，否则就会造成其它线程无法获得锁的情况。

Lock lock = new ReentrantLock();
Runnable runnable = new Runnable() {
    @Override
    public void run() {
        if (Thread.currentThread().getName().equalsIgnoreCase("thread1")) {
            funA();
        } else if (Thread.currentThread().getName().equalsIgnoreCase("thread2")) {
            funB();
        }
    }

    private void funA() {
        try {
            lock.lock();
            for (int i = 0; i < 5; i++) {
                try {
                    System.out.println("[" + Thread.currentThread().getName() + "] funA " + i);
                    Thread.sleep(500);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        } finally {
            lock.unlock();
        }
    }

    private void funB() {
        try {
            lock.lock();
            for (int i = 0; i < 5; i++) {
                try {
                    System.out.println("[" + Thread.currentThread().getName() + "] funB " + i);
                    Thread.sleep(500);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        } finally {
            lock.unlock();
        }
    }
};
new Thread(runnable, "thread1").start();
new Thread(runnable, "thread2").start();

输出结果：

[thread1] funA 0
[thread1] funA 1
[thread1] funA 2
[thread1] funA 3
[thread1] funA 4
[thread2] funB 0
[thread2] funB 1
[thread2] funB 2
[thread2] funB 3
[thread2] funB 4

扩充说明：

  1. ReentrantLock的unlock一般放在finally中进行，这是一个好习惯，避免忘记或者中间发生异常后导致不能解锁。
  2. ReentrantLock类的有两个构造函数，带boolean参版本的如果传入true，表示这是一个公平锁。公平锁的意思是若存多个等待获取锁的线程，谁等待的时间越来就先获取到锁。
  3. ReentrantLock锁可以将lock方法换成lockInterruptibly方法可以响应等待中的中断，意思就是当线程对象调用interrupt方法时，会抛出InterruptedException异常中止等待。
  4. ReentrantLock锁可以将lock方法换成tryLock方法从而进行限时等待，意思是当在指定超时时间内尝试去获取锁失败时，会抛出InterruptedException异常中止等待。tryLock方法返回获得锁结果，结false则也不再需要调用unLock。

7.2.1 ReentrantLock和 synchronized区别

  1. Synchronized是依赖于JVM实现的；而ReenTrantLock是JDK实现的。
  2. Synchronized由编译器去保证锁的加锁和释放；而ReenTrantLock需要手工声明来加锁和释放锁。
  3. synchronized不可响应中断，一个线程获取不到锁就一直等着；ReentrantLock可以在中断等待。
  4. 两者的性能上差不多了，在两种方法都可用的情况下，官方甚至建议使用synchronized。

7.3 volatile修饰变量

volatile修饰的变量具备可见性和有序性，所以使用volatile修饰变量来实现同步机制是Java提供的一种轻量级的同步机制。

  1. 所谓可见性就是一个线程修改的状态对另一个线程是马上可见的。因为每条线程本身存在着一个本地内存，而一般情况下并非立即同步到主内存中去。在多线程操作时因为线程A修改了某对像的值只在本线程内存中发生变化而未及时同步到主内存中，从而就会导致线程B依然读取的该对象明的旧值。在多线程中共享变量最实际就是加锁，但是因为锁是有性能成本，而在这场景中使用volatile就是最合理的方法。volatile的作用是某线程修改了声明为volatile的共享变量的值时，JVM会把该线程对应的本地内存中的变量的值强制刷新到主内存中，从而保证新值对于其他线程来说是可以立即得知的。
  2. 而所谓有序性就是禁止使用指令重排序。重排序通常是编译器或运行时环境为了优化程序性能而采取的对指令进行重新排序执行的一种手段，Java内存模型中允许编译器和处理器对指令进行重排序，虽然重排序过程不会影响到单线程执行的正确性，但是会影响到多线程并发执行的正确性，所以往往在使用synchronized进行双重检查判空的单例中一般都需要给单例对象加上volatile修饰。
  3. 另外要注意，volatile修饰的变量不保证原子性。

7.4 Atomic系列对象

在多线程下，像i++、++i之类的操作都是不安全的，在使用时不可避免的会用到同步锁进行锁定对象，而Atomic系统对象则通过一种线程安全的操作方法，是以原子方式更新对应值，从而可以不使用锁的情况下也能达到预期安全效果，而且效率还有可能比synchronized略高，Atomic系列对象有：AtomicBoolean、AtomicInteger、AtomicLong，等。它们内部其实也就是使用了Volatile属性来完成的。使用如下：

AtomicBoolean exist = new AtomicBoolean(false);
AtomicInteger number = new AtomicInteger(1);
new Thread(new Runnable() {
    @Override
    public void run() {
        exist.set(false);
        if (exist.compareAndSet(false, true)) {
            System.out.println("exists value: " + exist);
        } else {
            System.out.println("exists value: " + exist);
        }
        int result = number.incrementAndGet();
        System.out.println("number value: " + number);
        System.out.println("result value: " + result);

    }
}).start();

输出结果：

exists value: true
result value: 2
number value: 2

解说：

  1. compareAndSet方法第一个参数是期望判断返回的值，上面就是如果为false时方法就返回true；第二个参数是设置的新值，就是在判断完后立即设置的一个新值。
  2. incrementAndGet方法好比++i，所以示例中result和number的值都是2。

7.5 CopyOnWriteArrayList数组

CopyOnWriteArrayList其实是一个较为特殊的ArrayList。它内部对add、set等这系列可变操作时都会对底层数组进行一次新的复制，从而避免了线程并发中数据冲突的问题，所以CopyOnWriteArrayList对可变操作的开销是非常大的。但是如果数组用于遍历的操作多于可变操作时，CopyOnWriteArrayList是一个处理数组在多线程同步上很不错的选择。

8 线程挂起

所谓线程挂起就是指暂停线程的执行，使线程进行等待阻塞状态。

而恢复时就是让挂起的线程得以继续执行，使线程返回到就绪状态。

8.1 wait和notify使线程挂起和恢复

wait方法在同步方法或同步代码块中调用锁定对象的wait方法可让线程主动释放锁并进入等待阻塞状态，直到遇到再次调用锁定对象的notify()或notifyAll()方法才能重新获得锁唤醒线程。

wait方法还可以像sleep方法一样，带上一个时间参数，表示在指定时间内挂起后自动恢复。

wait和sleep都可使线程从运行状态进行就绪状态。但sleep方法是纯粹使线程休眠等待，而且并不会释放锁。

Runnable runnable = new Runnable() {
    private byte[] lock = new byte[0];

    @Override
    public void run() {
        if (Thread.currentThread().getName().equalsIgnoreCase("thread1")) {
            funA();
        } else if (Thread.currentThread().getName().equalsIgnoreCase("thread2")) {
            funB();
        }
    }

    private void funA() {
        synchronized (lock) {
            for (int i = 0; i < 5; i++) {
                try {
                    if (i == 2) {
                        lock.wait();
                    }
                    System.out.println("[" + Thread.currentThread().getName() + "] funA " + i);
                    Thread.sleep(500);
                } catch (Exception e) {
                    e.printStackTrace();
                    break;
                }
            }
        }
    }

    private void funB() {
        synchronized (lock) {
            for (int i = 0; i < 5; i++) {
                try {
                    System.out.println("[" + Thread.currentThread().getName() + "] funB " + i);
                    Thread.sleep(500);
                } catch (Exception e) {
                    e.printStackTrace();
                    break;
                }
            }
            lock.notify();
        }
    }
};
new Thread(runnable, "thread1").start();

// thread2有意保证晚一点再运行
try {
    Thread.sleep(100);
} catch (Exception e) {
    e.printStackTrace();
}
new Thread(runnable, "thread2").start();

输出结果：

[thread1] funA 0
[thread1] funA 1
[thread2] funB 0
[thread2] funB 1
[thread2] funB 2
[thread2] funB 3
[thread2] funB 4
[thread1] funA 2
[thread1] funA 3
[thread1] funA 4

8.1.1 notify方法和notifyAll方法的区别

假如现在存在着3个线程在进行工作，线程A在获得同步锁后调用wait方法后挂起了线程，轮到线程B获得同步锁，而线程B在处理过程中也调用了wait方法也挂起了线程。这时线程C获得同步锁后调用了notify方法。因为notify只能恢复线程A或线程B其中一个，具体哪个由JVM决定，那么线程A和线程B其中一个就会存在一直挂起不能恢复的情况； 而如果线程C调用的是notifyAll方法，则线程A和线程B都会被唤醒，只是由于锁的原因，当时还是只有一个线程获得了锁继续工作，另外的线程进入了等待阻塞状态，最终待前面的线程执行完毕解放锁后还是到得到恢复。

8.2 线程计数器 CountDownLatch

CountDownLatch是一个在java.util.concurrent下的类，它是一个同步辅助类，它也属于共享锁，其内部有一个int类型的属性表示可以同时并发并行的线程的数量，使用场景跟使用wait和notify使线程挂起和恢复很相似，但是它还不受锁的限制。例如可以在两个线程中进行随意挂起和恢复。

CountDownLatch countDownLatch = new CountDownLatch(1);

Runnable runnable = new Runnable() {

    @Override
    public void run() {
        if (Thread.currentThread().getName().equalsIgnoreCase("thread1")) {
            funA();
        } else if (Thread.currentThread().getName().equalsIgnoreCase("thread2")) {
            funB();
        }
    }

    private void funA() {
        for (int i = 0; i < 5; i++) {
            try {
                if (i == 2) {
                    countDownLatch.await();
                }
                System.out.println("[" + Thread.currentThread().getName() + "] funA " + i);
                Thread.sleep(100);
            } catch (Exception e) {
                e.printStackTrace();
                break;
            }
        }
    }

    private void funB() {
        for (int i = 0; i < 5; i++) {
            try {
                System.out.println("[" + Thread.currentThread().getName() + "] funB " + i);
                Thread.sleep(500);
            } catch (Exception e) {
                e.printStackTrace();
                break;
            }
        }
        countDownLatch.countDown();
    }
};



new Thread(runnable, "thread1").start();
try {
    Thread.sleep(1000);
} catch (Exception e) {
    e.printStackTrace();
}
new Thread(runnable, "thread2").start();

输出结果：

[thread1] funA 0
[thread1] funA 1
[thread2] funB 0
[thread2] funB 1
[thread2] funB 2
[thread2] funB 3
[thread2] funB 4
[thread1] funA 2
[thread1] funA 3
[thread1] funA 4

解说：

  1. 示例中thread1线程先执行，当遇到await方法后进行了挂起，待thread2线程执行完后调用了countDown后才得到恢复。
  2. 示例中CountDownLatch初始化时传入数字1表示遇到一次countDown方法调用后便恢复挂起。因为每使用一次countDown方法计数减1，当数值减到0时，await方法后的代码才可以继续执行，未到0之前将一直阻塞等待。

8.3 信号量Semaphore

Semaphore也属于共享锁，即多个线程可以同时获取，主要作用于控制并发中同一个时刻执行的线程数量，可以用来做限流器。示例：

Semaphore semaphore = new Semaphore(1, true);

for (int i = 0; i < 10; i++) {
    int finalI = i;
    new Thread(new Runnable() {
        @Override
        public void run() {
            try {
                semaphore.acquire();
                System.out.println("[" + Thread.currentThread().getName() + "], i: " + finalI + ", time: " +System.currentTimeMillis());
                Thread.sleep(2000);
                semaphore.release();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }).start();
}

输出结果：

[Thread-4], i: 0, time: 1697275769087
[Thread-5], i: 1, time: 1697275771088
[Thread-6], i: 2, time: 1697275773089
[Thread-7], i: 3, time: 1697275775090
[Thread-8], i: 4, time: 1697275777092
[Thread-9], i: 5, time: 1697275779093
[Thread-10], i: 6, time: 1697275781094
[Thread-11], i: 7, time: 1697275783095
[Thread-12], i: 8, time: 1697275785097
[Thread-13], i: 9, time: 1697275787098

解说：

  1. 示例中创建了一个信号量semaphore对象，虽然循环同时创建了10个线程异步执行，但因为semaphore的构造方法传入了1，表示同一时刻只允许一个线程运行；
  2. semaphore.acquire 方法表示获取了信号，这时其它线程需要进入阻塞状态，semaphore.release 方法表示释放信号，其它线程可以恢复状态；
  3. semaphore构造方法第二个参数fair 表示是否公平竞争，如果是则等待时间最长的线程(最早创建的线程)获取，如果不是则随机选择一个线程获取许可，默认是false。

9 线程死锁

所谓死锁是指多个进程（线程）因竞争资源而造成的一种互相等待的现象。

9.1 死锁产生的原因

1. 系统资源的竞争导致系统资源不足，以及资源分配不当，导致死锁。

2. 进程（线程）运行推进顺序不合适，进程（线程）在运行过程中，请求和释放资源的顺序不当，会导致死锁。

9.2 产生死锁的四个必要条件

1. 互斥条件：进程（线程）申请的资源在一段时间中只能被一个进程（线程）使用。

2. 请求与等待条件：进程（线程）已经拥有了一个资源，但是又申请新的资源，对拥有的资源保持不变 。

3. 不可剥夺条件：在一个进程（线程）没有用完，主动释放资源的时候，不能被抢占。

4. 循环等待条件：多个进程（线程）之间存在资源循环链。

9.3 如何避免死锁

1. 避免嵌套锁

如果只有一个对象锁，那是几乎不可能出现死锁情况的。嵌套锁往往是死锁最常见的原因，如果你已经持有一个资源，请一定要避免锁定另一个资源。而且在实际开发过程中应该尽量只锁需要的部分来避免嵌套锁。

2. 加锁顺序

如果在不得不使用嵌套锁的时候，那么一定要注意加锁的顺序。在嵌套锁中，如果每个线程访问加锁的顺序是一样的话，也是不会发生列锁情况的。但是，这种方式需要你事先知道所有可能会用到的锁。

9.4 一定会死锁的反例

Runnable runnable = new Runnable() {
    private byte[] lock1 = new byte[0];
    private byte[] lock2 = new byte[0];
    @Override
    public void run() {
        if (Thread.currentThread().getName().equalsIgnoreCase("thread1")) {
            funA();
        } else if (Thread.currentThread().getName().equalsIgnoreCase("thread2")) {
            funB();
        }
    }

    private void funA() {
        try {
            synchronized (lock1) {
                System.out.println("[" + Thread.currentThread().getName() + "] funA1");
                Thread.sleep(500);
                synchronized (lock2) {
                    System.out.println("[" + Thread.currentThread().getName() + "] funA2");
                    Thread.sleep(500);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    private void funB() {
        try {
            synchronized (lock2) {
                System.out.println("[" + Thread.currentThread().getName() + "] funB1");
                Thread.sleep(500);
                synchronized (lock1) {
                    System.out.println("[" + Thread.currentThread().getName() + "] funB2");
                    Thread.sleep(500);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
};
new Thread(runnable, "thread1").start();
new Thread(runnable, "thread2").start();

子云心
关注
  • 2
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
【Android】线程Thread的使用
SPYY的专栏
08-29 649
Android 使用 匿名 Thread
Android线程管理之Thread使用总结
LuckyDucky的博客
02-03 1206
今天先来总结一下Thread使用 Thead生命周期的几个状态 New 一旦被实例化之后就处于new状态 Runnable 调用了start函数之后就处于Runnable状态 Running 线程被cpu执行 调用run函数之后 就处于Running状态 Blocked 调用join()、sleep()、wait()使线程处于Blocked状态 Dead 线程的run()方法运行完毕或被中断或被异...
Android 多线程：Thread理解和使用总结
parasoft的专栏
04-15 581
转载自： https://www.jianshu.com/p/49349eee9abc Android Thread目录.png 一、Android中的Thread 定义：线程，可以看作是进程的一个实体，是CPU调度和分派的基本单位，它是比进程更小的能独立运行的基本单位。 1.1 Thread主要函数 函数名 作用 run() 线程运行时所执行的代码 sta...
全面详解Android实现多线程的几种方式（史上最全，最详细）
热门推荐
恬静释然的博客
11-19 3万+
一、目录 Android多线程实现方式包括： 二、基础使用 Android多线程实现的基础使用包括： 继承Thread类 实现Runnable接口 Handler 接下来对各个进行分析。 1、继承Thread类 1.1 简介 1.2 使用详解 （1）使用步骤 （2） 具体使用 // 步骤1：创建线程类 （继承自Thread类） class MyThread extends Thr...
展开说说：Android实现多线程几种方式
最新发布
Hidanchaofan的博客
05-04 882
Thread类的start()方法和run()方法的主要区别在于人家扮演的角色压根就不一样。以下是两者的主要区别： 首先达到的效果不同。run()方法是线程中实际运行的代码，他就是仅代表调用run方法而已；start()方法是启动一个新线程，它会创建一个新的线程并在新的线程中并行执行run方法的任务。因此在实际的多线程编程中，应该通过调用start()方法来启动线程。
Android中的Thread详解
Androiddddd的博客
11-17 632
线程（英语：thread）在计算机科学中，是将进程划分为两个或多个线程（实例）或子进程，由单处理器（单线程）或多处理器（多线程）或多核处理系统并发执行。—— 维基百科无论在Android还是java开发甚至其他语言开发，大多数都逃不过多线程的话题，当然dart等语言除外（不过也有isolate的概念）。线程是操作系统CPU资源分配调度的一个单元，在Java中，最常见的就是Thread类，通过该类可以让我们在多线程创建、启动、执行等操作更加得心应手。
Android Thread 浅析和使用小结
再简单的事，也要用心做成！
12-22 9610
一.线程的状态 线程包括几个状态： 创建（new) Thread thread=new Thread; 就绪（runnable） thread.start(); 运行（running） 线程只能从就绪状态进入到运行状态 阻塞（blocked） 该状态是线程因为某种原因放弃了cpu使用权限，暂时停止运行。 阻塞的情况有三种...
Android Thread线程的简单使用
u012841414的博客
11-09 1083
计时功能看似成功了，但是却埋下了一个隐患，即当你销毁计时界面（可以理解为出栈）时，启动的子线程不会因此而销毁，由于其还持有显示时间的控件tv_time，导致GC不会回收，一直持有该引用，轻则卡顿，重则占满内存导致OOM，直接奔溃。用来实现同步，可以保证被修饰的函数在被其它函数调用时，如果其处于被调用中，那么其它所有要调用到该函数的线程都会被阻塞，直到其从调用的线程中返回，防止资源冲突（虽然在上诉的代码中没有很好体现，但是还是粗略讲解下作用）至此，线程的简单使用到此结束，有不对的地方请各位小伙伴不吝指出。
Android使用线程更换壁纸
08-26
在Android中，可以使用`Thread`类、`AsyncTask`、`Handler`/`Looper`或`Runnable`配合`ExecutorService`来创建新线程。 在上述示例中，创建了一个新的`Thread`子类，并重写了`run()`方法。在这个方法中，我们实现了...
Android 线程thread的两种实现方法(必看)
01-20
这篇文章中有三点需要提前说明一下， 一：在android中有两种实现线程thread的方法： 一种是，扩展java.lang.Thread类 另一种是，实现Runnable接口 二：Thread类代表线程类，它的两个最主要的方法是： run()——包含线程运行时所执行的代码 Start()——用于启动线程 三： Handler 机制，它是Runnable和Activity交互的桥梁，在run方法中发送Message，在Handler里，通过不同的Message执行不同的任务。 下面分别给出两种线程的实现方法，其一，扩展java.lang.Thread类，也就是把run()方法写到线程里面：
Android线程的优先级设置方法技巧
09-02
总之，理解并合理运用Android线程优先级机制，可以帮助开发者创建更加高效、响应迅速的应用，提供更好的用户体验。在实际开发中，要结合具体场景选择合适的优先级，并避免滥用高优先级，以保持系统的稳定性和平衡性...
Android多线程下载实现方案
06-11
在Android开发中，为了提升用户体验，尤其是在处理大文件下载时，多线程技术的应用变得尤为重要。本篇文章将详细探讨如何在Android中实现多线程下载功能，并涉及断点续传技术，以确保下载的高效性和可靠性。我们还将...
Android中断并重启一个Thread线程的简单方法
08-31
在Android开发中，通常推荐使用`Handler`、`AsyncTask`或`ExecutorService`等更高级的并发工具来管理线程，因为它们提供了更丰富的控制和同步机制。然而，对于简单的线程控制需求，直接使用`Thread`类也是可行的，...
Android - 线程 Thread
HugMua的博客
06-02 935
一个线程总是由另一个线程启动，所以总有一条特殊的线程即主线程。
Android 线程的正确使用姿势
weixin_30607659的博客
05-03 1180
进程优先级（Process Priority） 线程寄宿在进程当中，线程的生命周期直接被进程所影响，而进程的存活又和其优先级直接相关。在处理进程优先级的时候，大部分人靠直觉都能知道前台进程（Foreground Process）优先级要高于后台进程（Background Process）。但这种粗糙的划分无法满足操作系统高精度调度的需求。无论Android还是iOS，系统对于Foreground...
android线程实现方法,Android 线程 thread 两种实现方法！
weixin_36160690的博客
05-25 2258
这篇文章中有三点需要提前说明一下，一：在Android中有两种实现线程thread的方法：一种是，扩展Java.lang.Thread类另一种是，实现Runnable接口二：Thread类代表线程类，它的两个最主要的方法是：run()——包含线程运行时所执行的代码Start()——用于启动线程三：Handler 机制，它是Runnable和Activity交互的桥梁，在run方法中发送Messag...
Android多线程分析之二：Thread的实现
罗朝辉（飘飘白云）
07-10 2万+
在前文《Android多线程分析之一：使用Thread异步下载图像》中演示了如何使用 Thread 处理异步事务。示例中这个 Java Thread 类都是位于 Framework 层的类，它自身是通过 JNI 转调 dalvik 里面的 Thread 相关方法实现的。因此要分析 Androd 中的线程，就需要分析这两层中的与线程相关的代码，这就是本文要探讨的主题。本文将把 Framework 层中的 Java Thread 称为 Android 线程/Thread，而把 dalvik 中的 Thread
android 在Thread中使用mqtt 代码
06-08
以下是在 Thread 中使用 MQTT 的示例代码： ```java public class MqttThread extends Thread { private MqttClient mqttClient; @Override public void run() { super.run(); String broker = "tcp://mqtt.eclipse.org:1883"; String clientId = MqttClient.generateClientId(); try { mqttClient = new MqttClient(broker, clientId); mqttClient.connect(); mqttClient.subscribe("topic/test", new IMqttMessageListener() { @Override public void messageArrived(String topic, MqttMessage message) throws Exception { // 收到消息 } }); } catch (MqttException e) { e.printStackTrace(); } } public void disconnect() { if (mqttClient != null && mqttClient.isConnected()) { try { mqttClient.disconnect(); } catch (MqttException e) { e.printStackTrace(); } } } } ``` 在 `run` 方法中，我们创建了一个 MQTT 客户端，并连接到 MQTT 服务器。然后订阅了一个主题，并设置了回调函数来处理收到的消息。 需要注意的是，由于 Thread 是多线程的，因此在 Thread 中进行耗时操作是可以的。但是，我们需要手动调用 `disconnect` 方法来断开 MQTT 客户端的连接，否则可能会导致连接一直保持，直到程序退出。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值