Java 多线程基础汇总

最新推荐文章于 2023-02-22 10:02:28 发布

HermioneZhou

最新推荐文章于 2023-02-22 10:02:28 发布

阅读量238

点赞数 2

分类专栏：多线程文章标签：多线程 Java Wait方法与notify方法

本文链接：https://blog.csdn.net/qq_36142320/article/details/89061842

版权

多线程专栏收录该内容

2 篇文章 0 订阅

订阅专栏

### 第一题：

/**
* 1、经典多线程题目。
*
* 启动3个线程打印递增的数字, 线程1先打印1,2,3,4,5, 然后是线程2打印6,7,8,9,10,
* 然后是线程3打印11,12,13,14,15.
* 接着再由线程1打印16,17,18,19,20….以此类推, 直到打印到75
* */
public class Thread02 {


   public static void main(String[] args) {

       Object obj = new Object();
       new Thread(new PrintRunnable(obj,1)).start();
       new Thread(new PrintRunnable(obj,2)).start();
       new Thread(new PrintRunnable(obj,3)).start();


   }
}

class PrintRunnable implements Runnable{
   //volatile在这里可加可不加。我试了几次，结果都是对的。

   private volatile static int printNum = 0;

   private Object o;

   private int threadId ;


   public PrintRunnable(Object o, int threadId) {

       this.o = o;
       this.threadId = threadId;
   }

   public void run(){

       synchronized(o){

           while(printNum<75){

//这个算法不错。
               if(printNum/5%3+1==threadId){
                   for(int i=0;i<5;i++){
                       // printNum++;
                       System.out.println("线程"+threadId+":"+(++printNum));

                   }
                   o.notifyAll();

               }else{
                   try {
                       //wait方法的含义：就是调用此方法后，此线程处于阻塞，
                       //直到它被唤醒，唤醒后，就继续执行wait方法后的语句。而不会
                       //再执行if里的语句了。要理解哈。

                       o.wait();

                   //   System.out.println(threadId+":等待");
                   } catch (InterruptedException e) {

                       e.printStackTrace();
                   }

               }

           }


       }


   }
}

## 第二题：

/**
*
* 2、现在有T1、T2、T3三个线程，你怎样保证T2在T1执行完后执行，T3在T2执行完后执行？
* */
public class Thread03 {


   public static void main(String[] args) {
       Thread03.method02();


   }

   private static void method02(){
   Runnable runnable = new Runnable() {
   @Override public void run() {
   System.out.println(Thread.currentThread().getName() + "执行完成");
   }
   };
   //在非main方法中也可以new对象啊。
   Thread t1 = new Thread(runnable, "t1");
   Thread t2 = new Thread(runnable, "t2");
   Thread t3 = new Thread(runnable, "t3");
   try {
   t1.start();
   //此处的join方法表示一定会在t2线程先执行完。

   t1.join();
   t2.start();


   t2.join();
   t3.start();
   t3.join();
   } catch (InterruptedException e) {
   e.printStackTrace();
   }
   }
}

## 第三题：

public static void main(String[] args) {

       //3、编写10个线程，第一个线程从1加到10，第二个线程从11加到20.....第十个线程从91加到100，
       //最后再把10个线程结果相加。
       Object obj = new Object();

       for(int i=0;i<10;i++){
           new ThreadZhou(obj,(i+1)).start();
       }

   }
}

//
class ThreadZhou extends Thread{
   private static int sum=0;

   private int threadId;

   private Object obj;
   private static int num=0;
   //一定要加上static
   static private int[] arr = new int[10];

   public ThreadZhou(Object obj,int threadId){
       this.obj = obj;

       this.threadId = threadId;
   }

   public void run(){

       synchronized(obj){

           while(num<100){
               if(num/10%10+1==threadId){
                   for(int i=0;i<10;i++){
                       num++;
                       arr[threadId-1]+=num;

                   }
                   System.out.println((threadId-1)+":"+arr[threadId-1]);
                   if(num==100){

                       for(int j=0;j<arr.length;j++){
                           //气死我了。？？结果不对？？
                               System.out.println("j:"+arr[j]);
                               sum+=arr[j];
                           }
                           System.out.println("sum:"+sum);
                   }
                   obj.notifyAll();
               }else{
                   try {

                           obj.wait();
                       } catch (InterruptedException e) {

                           e.printStackTrace();
                       }

               }

           }
           /*if(num==100){

           }*/
           /* if(num==100){

               System.out.print("\n");
           for(int j=0;j<arr.length;j++){
               //气死我了。？？结果不对？？
                   System.out.println("j:"+arr[j]);
                   sum+=arr[j];
               }
               System.out.println("sum:"+sum);
       }*/

       }
   }
}

##第四题：

生产者、消费者情形，之前也看到过，没有研究，今日花了点时间理解了哈。大有裨益。棒棒的。

有个共享资源类，Person类。

public class Person {


   private String name;

   private int age;
   //表示共享资源对象是否为空，如果为true,表示需要生产，如果为false，表示有数据了，不要生产。
   private boolean isEmpty=true;

   public synchronized void push(String name,int age){
       try {
       if(!isEmpty){

               this.wait();
           }

       //
       this.name = name;
       this.age = age;

       isEmpty = false;

       System.out.println("person:"+this);
       this.notifyAll();
       }catch (InterruptedException e) {

               e.printStackTrace();
           }

   }

   //取数据
   public synchronized void pop(){
       try{

           if(isEmpty){
               this.wait();

           }

           System.out.println(this.name+"---"+this.age);

           isEmpty = true;
           this.notifyAll();

       }catch(InterruptedException e){
           e.printStackTrace();

       }
   }

   @Override
   public String toString() {
       return "Person [name=" + name + ", age=" + age + "]";
   }


}

再写个类Thread05。调用main方法。就是多线程中的生产者-消费者模型了。

public class Thread05 {


   public static void main(String[] args) {

       Person p = new Person();

       Runnable producer = new Producer(p);
       Runnable consumer = new Consumer(p);

       Thread pro = new Thread(producer);
       Thread con = new Thread(consumer);

       pro.start();
       con.start();


   }
}

class Producer implements Runnable{

   Person p = null;

   public Producer(Person p){
       this.p = p;

   }

   public void run(){

       for(int i=0;i<50;i++){
           if(i%2==0){
               p.push("Tom", 11);

           }else{
               p.push("Marry", 20);
           }
       }
   }
}

class Consumer implements Runnable{

   Person p = null;

   public Consumer(Person p){
       this.p = p;
   }

   public void run(){

       for(int i=0;i<50;i++){
           p.pop();

       }
   }
}

## 第五题：

这个例子是演示wait方法与notify方法，即多线程通信的简单的例子。

public class ThreadWait01 {


   public static void main(String[] args) {

       Object obj = new Object();
       Thread t1 = new Wait(obj);

       Thread t2 = new Notify(obj);

       t1.start();
       t2.start();


   }
}

class Wait extends Thread{
   private Object obj;

   public Wait(Object obj){
       this.obj = obj;
   }

   public void run(){



           //模拟尽量让Wait类先执行。
       //Thread.sleep(1000);
           Thread.yield();


       synchronized(obj){
           for(int i=0;i<30;i++){
               Example.i++;

               if(i==11){
                   obj.notify();
                   System.out.println("已经发出唤醒消息了");
               }

               System.out.println("i:"+i);
           }

       }


   }

}

class Notify extends Thread{
   private Object obj;

   public Notify(Object obj){
       this.obj = obj;
   }

   public void run(){

       synchronized(obj){
           if(Example.i!=11){
               try {
                   System.out.println("wait start");
                       obj.wait();

                       System.out.println("wait end");
                   } catch (InterruptedException e) {

                       e.printStackTrace();
                   }

           }
       }

   }

}