Java多线程之线程间协作 notify与wait的使用

简介: (转载请注明出处:http://blog.csdn.net/buptgshengod) 1.背景        Java多线程操作运用很广,特别是在android程序方面。线程异步协作是多线程操作的难点也是关键,也是找工作面试经常考到的地方。下面分享一下我的使用心得。 介绍几个关键字: synchronized:线程锁,使得系统只执行当前线程。 notifyAll():唤

(转载请注明出处:http://blog.csdn.net/buptgshengod

1.背景

       Java多线程操作运用很广,特别是在android程序方面。线程异步协作是多线程操作的难点也是关键,也是找工作面试经常考到的地方。下面分享一下我的使用心得。

介绍几个关键字

synchronized:线程锁,使得系统只执行当前线程。

notifyAll():唤醒其它被锁住的线程

wait():挂起线程

ExecutorService exec=Executors.newCachedThreadPool();:创建线程池

exec.execute( new Runnable() ):将线程放到线程池中管理

2.代码部分

(1)

public class Thread2 {
     public void m4t1() {
          synchronized(this) {
               int i = 5;
               while(i>0) {
                    System.out.println("1");
                    i--;

                    try {
                         Thread.sleep(500);

                    } catch (InterruptedException ie) {
                    }
               }
          }
     }
     public void m4t2() {
        // synchronized(this){
         int i = 5;
          while( i > 0) {
               System.out.println("2");
               i--;
               try {
                    Thread.sleep(500);

               } catch (InterruptedException ie) {
               }
          }

     }
     public static void main(String[] args) {
          final Thread2 myt2 = new Thread2();
          Thread t1 = new Thread(  new Runnable() {  public void run() {  myt2.m4t1();  }  }, "t1"  );
          Thread t2 = new Thread(  new Runnable() {  public void run() { myt2.m4t2();   }  }, "t2"  );
          t1.start();
          t2.start();

     }
}

我们发现,两个线程其中一个上了锁,另一个没有上锁。运行结果如下。说明了虽然一个线程上了锁,但是还是能被让其它未上锁线程访问。

(2)

当我们给两个方法都加上锁

public class Thread2 {
     public void m4t1() {
          synchronized(this) {
               int i = 5;
               while(i>0) {
                    System.out.println("1");
                    i--;

                    try {
                         Thread.sleep(500);

                    } catch (InterruptedException ie) {
                    }
               }
          }
     }
     public void m4t2() {
        synchronized(this){
         int i = 5;
          while( i > 0) {
               System.out.println("2");
               i--;
               try {
                    Thread.sleep(500);

               } catch (InterruptedException ie) {
               }
          }
        }

     }
     public static void main(String[] args) {
          final Thread2 myt2 = new Thread2();
          Thread t1 = new Thread(  new Runnable() {  public void run() {  myt2.m4t1();  }  }, "t1"  );
          Thread t2 = new Thread(  new Runnable() {  public void run() { myt2.m4t2();   }  }, "t2"  );
          t1.start();
          t2.start();

     }
}
运行结果变成了

先执行完第一个锁中的内容后执行第二个锁中的内容。


(3)

这时候我们使用notifyAll()和wait()

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Thread2 {
     public void m4t1() {
          synchronized(this) {
               int i = 5;
               while(i>0) {
                    System.out.println("1");
                    i--;

                    try {
                         Thread.sleep(500);
                         notifyAll();
                         wait();
                    } catch (InterruptedException ie) {
                    }
               }
          }
     }
     public void m4t2() {
        synchronized(this){
         int i = 5;
          while( i > 0) {
               System.out.println("2");
               i--;
               try {
                    Thread.sleep(500);
                    notifyAll();
                    wait();
               } catch (InterruptedException ie) {
               }
          }
        }

     }
     public static void main(String[] args) {
          final Thread2 myt2 = new Thread2();
          Thread t1 = new Thread(  new Runnable() {  public void run() {  myt2.m4t1();  }  }, "t1"  );
          Thread t2 = new Thread(  new Runnable() {  public void run() { myt2.m4t2();   }  }, "t2"  );
          t1.start();
          t2.start();

     }
}

通过不断的唤醒再挂起,两个线程又交替运行。


(4)

如果想让代码更完善,可以将两个线程放到线程池

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Thread2 {
     public void m4t1() {
          synchronized(this) {
               int i = 5;
               while(i>0) {
                    System.out.println("1");
                    i--;

                    try {
                         Thread.sleep(500);
                         notifyAll();
                         wait();
                    } catch (InterruptedException ie) {
                    }
               }
          }
     }
     public void m4t2() {
        synchronized(this){
         int i = 5;
          while( i > 0) {
               System.out.println("2");
               i--;
               try {
                    Thread.sleep(500);
                    notifyAll();
                    wait();
               } catch (InterruptedException ie) {
               }
          }
        }

     }
     public static void main(String[] args) {
          final Thread2 myt2 = new Thread2();
         ExecutorService exec=Executors.newCachedThreadPool();
         exec.execute( new Runnable() {  public void run() {  myt2.m4t1();  }  });
         exec.execute( new Runnable() {  public void run() {  myt2.m4t2();  }  });
     }
}


目录
相关文章
|
1天前
|
监控 安全 Java
Java多线程编程的艺术与实践
【10月更文挑战第22天】 在现代软件开发中,多线程编程是一项不可或缺的技能。本文将深入探讨Java多线程编程的核心概念、常见问题以及最佳实践,帮助开发者掌握这一强大的工具。我们将从基础概念入手,逐步深入到高级主题,包括线程的创建与管理、同步机制、线程池的使用等。通过实际案例分析,本文旨在提供一种系统化的学习方法,使读者能够在实际项目中灵活运用多线程技术。
|
2天前
|
Java 数据处理 开发者
Java多线程编程的艺术:从入门到精通####
【10月更文挑战第21天】 本文将深入探讨Java多线程编程的核心概念,通过生动实例和实用技巧,引导读者从基础认知迈向高效并发编程的殿堂。我们将一起揭开线程管理的神秘面纱,掌握同步机制的精髓,并学习如何在实际项目中灵活运用这些知识,以提升应用性能与响应速度。 ####
14 3
|
3天前
|
Java
Java中的多线程编程:从入门到精通
本文将带你深入了解Java中的多线程编程。我们将从基础概念开始,逐步深入探讨线程的创建、启动、同步和通信等关键知识点。通过阅读本文,你将能够掌握Java多线程编程的基本技能,为进一步学习和应用打下坚实的基础。
|
4天前
|
Java 开发者
在Java多线程编程中,选择合适的线程创建方法至关重要
【10月更文挑战第20天】在Java多线程编程中,选择合适的线程创建方法至关重要。本文通过案例分析,探讨了继承Thread类和实现Runnable接口两种方法的优缺点及适用场景,帮助开发者做出明智的选择。
8 2
|
2天前
|
监控 安全 Java
在 Java 中使用线程池监控以及动态调整线程池时需要注意什么?
【10月更文挑战第22天】在进行线程池的监控和动态调整时,要综合考虑多方面的因素,谨慎操作,以确保线程池能够高效、稳定地运行,满足业务的需求。
67 38
|
3天前
|
Java 调度
[Java]线程生命周期与线程通信
本文详细探讨了线程生命周期与线程通信。文章首先分析了线程的五个基本状态及其转换过程,结合JDK1.8版本的特点进行了深入讲解。接着,通过多个实例介绍了线程通信的几种实现方式,包括使用`volatile`关键字、`Object`类的`wait()`和`notify()`方法、`CountDownLatch`、`ReentrantLock`结合`Condition`以及`LockSupport`等工具。全文旨在帮助读者理解线程管理的核心概念和技术细节。
14 1
[Java]线程生命周期与线程通信
|
1天前
|
安全 Java
在 Java 中使用实现 Runnable 接口的方式创建线程
【10月更文挑战第22天】通过以上内容的介绍,相信你已经对在 Java 中如何使用实现 Runnable 接口的方式创建线程有了更深入的了解。在实际应用中,需要根据具体的需求和场景,合理选择线程创建方式,并注意线程安全、同步、通信等相关问题,以确保程序的正确性和稳定性。
|
2天前
|
Prometheus 监控 Cloud Native
JAVA线程池监控以及动态调整线程池
【10月更文挑战第22天】在 Java 中,线程池的监控和动态调整是非常重要的,它可以帮助我们更好地管理系统资源,提高应用的性能和稳定性。
18 4
|
2天前
|
Prometheus 监控 Cloud Native
在 Java 中,如何使用线程池监控以及动态调整线程池?
【10月更文挑战第22天】线程池的监控和动态调整是一项重要的任务,需要我们结合具体的应用场景和需求,选择合适的方法和策略,以确保线程池始终处于最优状态,提高系统的性能和稳定性。
16 2
|
4天前
|
Java 开发者
在Java多线程编程中,创建线程的方法有两种:继承Thread类和实现Runnable接口
【10月更文挑战第20天】在Java多线程编程中,创建线程的方法有两种:继承Thread类和实现Runnable接口。本文揭示了这两种方式的微妙差异和潜在陷阱,帮助你更好地理解和选择适合项目需求的线程创建方式。
10 3