java多线程

实验过程：

（源程序代码，即.java文件）

第一题:

/*1、  建立一个线程，其任务是每隔1s生成一个随机数；要求分别使用以下方法：

   继承Thread类

  实现Runnable接口的方法

*/

package szu.cn;

import java.util.*;

 

public class thread_1 extends Thread  {

 

    /**

     * @param args

     */

    public void run(){

        while(true){

        Random random1=new Random();

        System.out.println(this.currentThread()+"thread方式随机数为："+random1.nextInt());

        try {

            sleep(1000);

        } catch (InterruptedException e) {

            // TODO Auto-generated catch block

            e.printStackTrace();

        }

        }

    }

    public static void main(String[] args) {

        // TODO Auto-generated method stub

           System.out.println("nimen");

           thread_1 thread1=new thread_1();

           threadrunable thread_runable=new threadrunable();

           Thread thrd_run=new Thread(thread_runable);

           thread1.start();

           thrd_run.start();

         }

 

}

class threadrunableimplements Runnable {

 

    @Override

    public void run() {

        // TODO Auto-generated method stub

        while(true){

            Random random1=new Random();

            System.out.println("runable方式随机数为："+random1.nextInt());

            try {

                Thread.sleep(1000);

            } catch (InterruptedException e) {

                // TODO Auto-generated catch block

                e.printStackTrace();

            }

            }

       

    }

 

 

   

}

第二题：

package szu.cn;

 

import java.util.Random;

 

/*要求：两个线程同时运行，一个线程负责生成随机数，每生成一个休眠1s；

 * 另外一个线程逐个检查该检查随机数，确定它是否是素数，每检查一个休眠1s。

 * 主线程负责检查生成的随机数超过90就结束程序。*/

public class thread_2 {

 

    /**

     * @param args

     */

    public static void main(String[] args) {

        // TODO Auto-generated method stub

       Check check=new Check();

       random_1 ran=new random_1(check);

       Thread t1=new Thread(ran);

       t1.start();

       check_num ch=new check_num(check);

       Thread t2=new Thread(ch);

       t2.start();

       while(check.num!=10){

        try {

            Thread.sleep(1);

        } catch (InterruptedException e) {

            // TODO Auto-generated catch block

            e.printStackTrace();

        }

       }

      check.flag=false;

    }

 

}

class random_1implements Runnable{

    Check check;

    random_1(Check check){

        this.check=check;

    }

    @Override

    public void run() {

        // TODO Auto-generated method stub

     

        while(check.flag){

            //  synchronized(check){

              check.random_t();

             try {

                  Thread.sleep(1000);

             }    catch (InterruptedException e) {

            // TODO Auto-generated catch block

                       e.printStackTrace();

                   }

        //}

     }

    }

}

class check_numimplements Runnable{

    Check check;

    check_num (Check check){

        this.check=check;

    }

    @Override

    public void run() {

        // TODO Auto-generated method stub

        //System.out.println("是素数");

       

        while(check.flag){

            //if(check.num==90) break;

            //int sushu=check.sushu;

        check.sushu(check.sushu);

        try {

             Thread.sleep(1000);

         }   catch (InterruptedException e) {

            // TODO Auto-generated catch block

                 e.printStackTrace();

             }

            }

       

    }

   

}

class Check {

    int num=0;

    int sushu;

    boolean flag=true;

    synchronized  void random_t(){

         Random random1=new Random();

         sushu=random1.nextInt()%100;

            System.out.println("第"+num+"随机数为:"+sushu);

            num++;

     }

    synchronized  boolean sushu(int ar){//这种方法判断素数效率很低，可以利用筛选法进行素数的判断

      boolean tag=true;

      if(ar<2)return tag;

      for(int i=ar-1;i>1;i--){

          if(ar%i==0){

              tag=false;

              break; 

          }

      } 

      if(tag)

      System.out.println(ar+"是素数");

      return tag;

  }

 

}

 

第三题：

 

package szu.cn;

 

import java.text.SimpleDateFormat;

import java.util.Date;

 

/*编写java应用程序，在主线程中有2个线程：PrintTime和Supervisor。线程PrintTime负责输出当前的时间，共输出10个

 * ，每输出一个就准备休息5s。Supervisor线程一直在吵醒PrintTime线程。当PrintTime工作完成后，Supervisor线程也结束运行。*/

public class thread_3 {

      public static void main(String[] args) {

            PrintTime tr1=new PrintTime();

            tr1.start();

            Supervisor tr2=new Supervisor(tr1);

            tr2.start();

      }

}

 

class PrintTimeextends Thread {

    int num=0;

    boolean flag=true;

    @Override

    public void run() {

      

            System.out.println("start");

            while(num<10) {

                ///

                //数据处理

                ///

              SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//设置日期格式

              System.out.println(df.format(new Date()));// new Date()为获取当前系统时间

              num++;

              try {

                    sleep(5000);

                } catch (InterruptedException e) {

                    // TODO Auto-generated catch block

                //  e.printStackTrace();

                }  

            }

      

        //System.out.println("stop");

        //super.run();

        flag=false;

    } 

}

 

class Supervisorextends Thread {

     PrintTime p;

     Supervisor(PrintTime p){

        this.p=p;

        }

    @Override

    public void run() {

      while(p.flag){

      try {

            sleep(1000);

        } catch (InterruptedException e) {

            // TODO Auto-generated catch block

            e.printStackTrace();

        }

      p.interrupt();

        //super.run();

      }

    } 

}

 

 

 

 

 

实验结果及数据处理分析：

 

      （ 运行程序截图）

      第一题:

第二题：

第三题：

 

实验结论：

  多线程可以提高资源的利用率，但是多线程中的公用的资源部分要进行同步。Sleep和wait的区别：

1这两个方法来自不同的类分别是Thread和Object

2. 最主要是sleep方法没有释放锁，而wait方法释放了锁，使得其他线程可以使用同步控制块或者方法。

3.s leep必须捕获异常，而wait，notify和notifyAll不需要捕获异常

 

实验收获及思考

    （实验心得）

线程同步是个很重要的概念：与linux C编程的同步锁，条件变量锁是有同工之美；

sleep属于程序的，如果睡不好就会有异常，如被interreput了，而wait是属于对象的，就没有异常这个概念了

wait的概念和C下的linux编程的条件变量锁的概念是一样的。