精华内容
下载资源
问答
  • 实验5Java多线程实验目的 1了解线程的概念 2学习简单的多线程编程 二实验任务 1阅读理解给定的Java Application程序 2按要求编写一个Java Application程序并编译运行这个程序 三实验内容 编写3个线程销售10张票...
  • 实验9多线程设计.doc
  • Java实验8 多线程编程

    2020-06-18 21:26:03
    用实现Runnable接口的方法实现多线程。 程序设计思路: 利用Runnable接口来创建 程序代码: package java_experiment_eight; class Tickets implements Runnable{ private int ticket=100; @Override public void...

    实验内容:
    (1)编程模拟售票系统,模拟多个窗口(至少4个)同时出售100张车票的情况;用实现Runnable接口的方法实现多线程。
    程序设计思路:
    利用Runnable接口来创建
    程序代码:

    package java_experiment_eight;
    class Tickets implements Runnable{
    	private int ticket=100;
    	@Override
    	public void run() {
    		while(true) {
    			synchronized(this){
    				if(ticket>0) {					
    					System.out.println(Thread.currentThread().getName()+"剩余"+ticket+"张票");
    					ticket--;
    				}
    				else {
    					break;	
    				}
    			}
    			try {
    				Thread.sleep(100);
    			}catch(Exception e) {
    				System.out.println(e.getMessage());
    			}
    		}
    	}
    }
    public class SellTickets{
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		Tickets sellTickets=new Tickets();
    		Thread win1=new Thread(sellTickets);
    		Thread win2=new Thread(sellTickets);
    		Thread win3=new Thread(sellTickets);
    		Thread win4=new Thread(sellTickets);
    		win1.setName("win-1");
    		win2.setName("win-2");
    		win3.setName("win-3");
    		win4.setName("win-4");
    		win1.start();
    		win2.start();
    		win3.start();
    		win4.start();
    	}
    }
    

    运行截图:
    在这里插入图片描述在这里插入图片描述在这里插入图片描述
    实验内容:
    (2)利用多线程机制编写程序,输出一个问候语,要求每隔1秒钟输出一个字符。用2种方法分别创建线程。
    例如:问候语=“welcome!”,运行结果可能有多种情况,如下表所示,分别说明原因及创建线程的方法。
    程序设计思路:
    在这里插入图片描述
    程序代码运行截图:
    图一:
    在这里插入图片描述
    图二:
    在这里插入图片描述
    图三:
    在这里插入图片描述
    图四:
    在这里插入图片描述

    展开全文
  • JAVA 实验多线程

    2010-12-26 11:26:56
    1. 掌握线程、多线程的概念和线程的生命周期; 2. 掌握创建单线程和多线程的方法,学会使用Thread类和实现Runnable接口。
  • java 多媒体与多线程处理实验 java实验报告
  • Java上机实验 多线程

    千次阅读 2020-05-27 22:51:43
    TypeKey.java public class TypeKey { public static void main(String args[]){ System.out.println("键盘练习(输入#结束程序)"); System.out.println("输入显示的字母(回车)\n"); Letter letter; letter=...

    实验1 键盘的操作练习

    TypeKey.java

    public class TypeKey {
     public static void main(String args[]){
      System.out.println("键盘练习(输入#结束程序)");
      System.out.println("输入显示的字母(回车)\n");
      Letter letter;
      letter=new Letter();
      GiveLetterThread giveChar;
      InputLetterThread typeChar;
      giveChar=new GiveLetterThread();//创建线程giveChar
      giveChar.setLetter(letter);
      giveChar.setSleepLength(3200);
      typeChar=new InputLetterThread();//创建线程typeChar
      typeChar.setLetter(letter);
      giveChar.start();
      typeChar.start();
     }
    }

    Letter.java

    public class Letter {
     char c='\0';
     public void setChar(char c){
      this.c=c;
     }
     public char getChar(){
      return c;
     }
    }

    GiveLetterThread.java

    public class GiveLetterThread extends Thread {
     Letter letter;
     char startChar='a',endChar='z';
     int sleepLength=5000;
     public void setLetter(Letter letter){
      this.letter=letter;
     }
     public void setSleepLength(int n){
      sleepLength=n;
     }
     public void run(){
      char c=startChar;
      while(true){
       letter.setChar(c);
       System.out.printf("显示的字符:%c\n",letter.getChar());
       try{
        Thread.sleep(sleepLength);//调用sleep方法使得线程中断sleepLength毫秒
       }
       catch (InterruptedException e) {}
       c=(char)(c+1);
       if(c>endChar)
        c=startChar;
      }
     }
    }

    InputLetterThread.java

    import java.awt.*;
    import java.util.*;
    public class InputLetterThread extends Thread {
     Scanner reader;
     Letter letter;
     int score=0;
     InputLetterThread(){
      reader=new Scanner(System.in);
     }
     public void setLetter(Letter letter){
      this.letter=letter;
     }
     public void run(){
      while(true){
       String str=reader.nextLine();
       char c=str.charAt(0);
       if(c==letter.getChar()){
        score++;
        System.out.printf("\t\t输入对了,目前分数%d\n",score);
       }
       else{
        System.out.printf("\t\t输入错了,目前分数%d\n",score);
       }
       if(c=='#') 
        System.exit(0);
      }
     }
    }
    

    实验2 双线程猜字

    TwoThreadGuessNumber.java

    public class TwoThreadGuessNumber {
     public static void main(String args[]){
      Number number=new Number();
      number.giveNumberThread.start();
      number.guessNumberThread.start();
     }
    }

    Number.java

    public class Number implements Runnable {
     final int SMALLER=-1,LARGER=1,SUCCESS=8;
     int realNumber,guessNumber,min=0,max=100,message=SMALLER;
     boolean pleaseGuess=false,isGiveNumber=false;
     Thread giveNumberThread,guessNumberThread;
     Number(){
      giveNumberThread=new Thread(this);
      guessNumberThread=new Thread(this);
     }
     public void run() {
      for(int count=1;true;count++){
       setMessage(count);
       if(message==SUCCESS)
        return;
      }
     }
     public synchronized void setMessage(int count){
      if(Thread.currentThread()==giveNumberThread&&isGiveNumber==false){
       realNumber=(int)(Math.random()*100)+1;
       System.out.println("随机给你安排一个1至100之间的数,猜猜是多少?");
       isGiveNumber=true;
       pleaseGuess=true;
      }
      if(Thread.currentThread()==giveNumberThread){
       while(pleaseGuess==true)
        try{
         wait();
        }
        catch(InterruptedException e){}
       if(realNumber>guessNumber){
        message=SMALLER;
        System.out.println("你猜小了");
       }
       else if(realNumber>guessNumber){
        message=SMALLER;
        System.out.println("你猜大了");
       }
       else{
        message=SUCCESS;
        System.out.println("恭喜,你猜对了");
       }
       pleaseGuess=true;
      }
      if(Thread.currentThread()==guessNumberThread&&isGiveNumber==true){
       while(pleaseGuess==false)
        try{
         wait();
        }
        catch(InterruptedException e){}
        if(message==SMALLER){
         min=guessNumber;
         guessNumber=(min+max)/2;
         System.out.println("我第"+count+"次猜这个数是:"+guessNumber);
        }
        else if(message==LARGER){
         max=guessNumber;
         guessNumber=(min+max)/2;
         System.out.println("我第"+count+"次猜这个数是:"+guessNumber);
        }
        pleaseGuess=false;
      }
      notifyAll();
     }
    }

    实验3 汉字打字练习

    ThreadWordMainClass.java

    public class ThreadWordMainClass{  
     public static void main(String args[]){
           new ThreadFrame().setTitle("汉字打字练习");
       }
    }
    

    WordThread.java

    import javax.swing.*;
    public class WordThread extends Thread{
     char word;
     int startPosition =19968; //Unicode 表的19968 ~ 32320位上的汉字
     int endPosition = 32320;
     JTextField showWord;
     int sleepLength = 6000;
     public void setJTextField(JTextField t) {
      showWord = t;
      showWord.setEditable (false);
     }
     public void setSleepLength(int n) {
      sleepLength = n;
     }
     public void run() {
      int k=startPosition;
      while(true) {
       word= (char)k;
       showWord. setText (""+word) ; 
       try{ sleep(sleepLength);//调用sleep方法使得线程中断sleepLength毫秒
       }
       catch (InterruptedException e) {}
       k++;
      if (k>=endPosition)
       k=startPosition; 
      }
     }
    }

    ThreadFrame.java

    import java.awt.*;
    import java.awt.event.*;
    import javax.swing.*;
    public class ThreadFrame extends JFrame implements ActionListener {
     JTextField showWord;
     JButton button;
     JTextField inputText, showScore;
     WordThread giveWord;//用WordThread声明一个giveWord线程对象
     int score=0;
     ThreadFrame() {
      showWord = new JTextField(6) ;
      showWord. setFont (new Font ("", Font . BOLD, 72)) ;
      showWord. setHorizontalAlignment (JTextField.CENTER ) ;
      giveWord=new WordThread();//创建giveWord线程
      giveWord.setJTextField (showWord) ;
      giveWord.setSleepLength (5000) ; 
      button=new JButton("开 始") ;
      inputText = new JTextField(10) ;
      showScore = new JTextField(5) ;
      showScore .setEditable (false) ;
      button. addActionListener (this) ;
      inputText . addActionListener (this) ;
      add (button, BorderLayout . NORTH) ;
      add ( showWord, BorderLayout . CENTER) ;
      JPanel southP=new JPanel () ;
      southP.add (new JLabel ("输入汉字(回车) :"));
      southP.add (inputText) ;
      southP.add (showScore) ;
      add(southP, BorderLayout . SOUTH) ;
      setBounds (100, 100, 350, 180) ;
      setVisible(true) ;
      validate() ;
      setDefaultCloseOperation (JFrame.EXIT_ON_CLOSE);
     }
     public void actionPerformed(ActionEvent e) {
      if (e. getSource ()==button) {
       if(!(giveWord. isAlive())) {
        giveWord=new WordThread();//创建giveWord
        giveWord.setJTextField (showWord);
        giveWord.setSleepLength (5000);
       }
       try {
        giveWord.start();//giveWord调用start()方法
       }
       catch (Exception exe) {}
       }
      else if (e.getSource ()==inputText) {
       if (inputText. getText () .equals (showWord.getText()))
        score++ ;
       showScore.setText ("得分:"+score) ;
       inputText.setText (null) ;
      }
     }
    }

    实验4 月球围绕地球

    MainClass.java

    import javax. swing.*;
    public class MainClass {
     public static void main(String args[]) {
      Sky sky= new Sky() ;
      JFrame frame = new JFrame() ;
      frame.add(sky);
      frame.setSize (500, 500) ;
      frame.setVisible(true) ;
      frame.setDefaultCloseOperation (JFrame.EXIT_ON_CLOSE) ;
      frame.getContentPane().setBackground(java.awt.Color.white) ;
     }
    }

    Earth.java

    import java.awt.*;
    import javax . swing.*;
    import java.awt.event. *;
    public class Earth extends JLabel implements ActionListener {
     JLabel moon;//显示月亮的外观
     Timer timer;
     double pointX[] =new double [360],pointY[]=new double[360] ;
     int w=200, h=200, i=0;
     Earth(){
      setLayout (new FlowLayout()) ;
      setPreferredSize (new Dimension(w,h)) ;
      timer=new Timer(20,this);//创建timer,振铃间隔是20毫秒当前Earth对象为其监视器
      setIcon(new ImageIcon("earth.jpg"));
      setHorizontalAlignment(SwingConstants.CENTER) ;
      moon=new JLabel (new ImageIcon ("moon.jpg"),SwingConstants.CENTER) ;
      add (moon) ;
      moon. setPreferredSize (new Dimension(60,60) ) ;
      pointX[0]=0;
      pointY[0]=h/2;
      double angle=1*Math.PI/180;//刻度为1度
      for(int i=0;i<359;i++){ //计算出数组中 各个元素的值
       pointX[i+1]=pointX[i]*Math.cos(angle)-Math.sin(angle)*pointY[i];
       pointY[i+1]=pointY[i]*Math.cos(angle)+pointX[i]*Math.sin(angle);
      }
      for(int i=0;i<360;i++) {
       pointX[i]=0.8*pointX[i]+w/2; //坐标缩放, 平移
       pointY[i]=0.8*pointY[i] +h/2;
      }
      timer.start();
     }
     public void actionPerformed (ActionEvent e) {
      i=(i+1)%360;
      moon.setLocation( (int)pointX[i]-30, (int)pointY[i]-30) ;
     }
    }
    

    Sky.java

    import java.awt. *;
    import javax. swing.*;
    import java.awt.event. *;
    public class Sky extends JLabel implements ActionListener {
     Earth earth;
     Timer timer;
     double pointX[]=new double[360],pointY[]=new double [360];
     int w=400,h=400,i=0;
     Sky(){ 
      setLayout (new FlowLayout()) ;
      timer=new Timer(100,this);//创建timer,振铃间隔是100毫秒当前Sky对象为其监视器.
      setPreferredSize(new Dimension(w,h));
      earth=new Earth() ;
      add(earth);
      earth. setPreferredSize (new Dimension (200, 200) ) ;
      pointX[0]=0;
      pointY[0]=h/2;
      double angle=1*Math.PI/180; //刻度为1度
      for(int i=0;i<359;i++) {//计算出数组中各个元素的值
       pointX[i+1]=pointX[i] *Math.cos(angle)-Math.sin(angle)*pointY[i];
       pointY[i+1]=pointY[i] *Math.cos(angle)+pointX[i]*Math.sin(angle);
      }
      for (int i=0;i<360;i++) {
       pointX[i]=0.5*pointX[i]+w/2; //坐标缩放、 平移
       pointY[i]=0.5*pointY[i] +h/2;
      }
      timer.start () ;
     }
     public void actionPerformed (ActionEvent e) {
      i=(i+1)%360;
      earth.setLocation((int)pointX[i]-100,(int)pointY[i]-100);
     }
    }

    ZZU_CZZ/2020/5_27/22:49

    展开全文
  • 编写一个Java应用程序,在主线程中再创建一个Frame类型的窗口,在该窗口中再创建1个线程giveWord。线程giveWord每隔2秒钟给出一个汉字,用户使用一种汉字输入法将该汉字输入到文本框中。 package lzy; public class...

    1.汉字打字练习。

    ²  实验要求:

    编写一个Java应用程序,在主线程中再创建一个Frame类型的窗口,在该窗口中再创建1个线程giveWord。线程giveWord每隔2秒钟给出一个汉字,用户使用一种汉字输入法将该汉字输入到文本框中。

    package lzy;
    public class ThreadWordMainClass
    {  public static void main(String args[])
       {
           new ThreadFrame();
       }
    }
    

    package lzy;
    
    import java.awt.*;
    import java.awt.event.*;
    public class ThreadFrame extends Frame implements ActionListener
    {
       Label  wordLabel;
       Button button;
       TextField inputText,scoreText;
       WordThread  giveWord;//用WordThread声明一个giveWord对象
       int score=0;
       ThreadFrame()
       { wordLabel=new Label(" ",Label.CENTER);
         wordLabel.setFont(new Font("",Font.BOLD,72));
         button=new Button("开始");
         inputText=new TextField(3);
         scoreText=new TextField(5);
         scoreText.setEditable(false);
        giveWord=new WordThread(wordLabel);//创建giveWord,将wordLabel传递给WordThread构造方法的参数
         button.addActionListener(this);
         inputText.addActionListener(this);
         add(button,BorderLayout.NORTH);
         add(wordLabel,BorderLayout.CENTER);
         Panel southP=new Panel();
         southP.add(new Label("输入标签所显示的汉字后回车:"));
         southP.add(inputText);
         southP.add(scoreText);
         add(southP,BorderLayout.SOUTH);
         setBounds(100,100,350,180);
         setVisible(true);
         validate();
         addWindowListener(new WindowAdapter()
                            { public void windowClosing(WindowEvent e)
                               { System.exit(0);
                               }
                            }
                           );
       }
      public void actionPerformed(ActionEvent e)
       {
          if(e.getSource()==button)
          {  if(!(giveWord.isAlive()))     //giveWord调用方法isAlive()
             {    giveWord=new WordThread(wordLabel);
             }
             try
             {    giveWord.start();//giveWord调用方法start()
             }
             catch(Exception exe){}
          }
          else if(e.getSource()==inputText)
          {  if(inputText.getText().equals(wordLabel.getText()))
              {  score++;
              }
             scoreText.setText("得分:"+score);
             inputText.setText(null);
          }
       }
    }
    

    package lzy;
    
    import java.awt.*;
    public class WordThread extends Thread
    {   char word;
        int k=19968;
        Label com;
        WordThread(Label com)
        {  this.com=com;
        }
        public void run()
        {  k=19968;
           while(true)
            {
              word=(char)k;
              com.setText(""+word);
              try{
                  sleep(6000);//调用sleep方法使得线程中断6000豪秒
                 }
              catch(InterruptedException e){}
               k++;
              if(k>=29968) k=19968;
            }
        }
    }
    
    
    


    2.旋转的行星。

    ²  实验要求:

    编写一个应用程序,模拟月亮围绕地球旋转、地球围绕太阳旋转。

    package lzy;
    
    public class ThreadRotateMainClass
    {  public static void main(String args[])
       {
           new HaveThreadFrame();
       }
    }
    

    package lzy;
    
    import java.awt.*;
    public class Mycanvas extends Canvas
    {
        int r;
       Color c;
       public void setColor(Color c)
       {
           this.c=c;
       }
       public void setR(int r)
       {
           this.r=r;
       }
       public void paint(Graphics g)
       {
           g.setColor(c);
         g.fillOval(0,0,2*r,2*r);
       }
       public int getR()
       {
           return r;
       }
    }
    

    package lzy;
    
    import java.awt.*;
    import java.awt.event.*;
    public class HaveThreadFrame extends Frame implements Runnable
    {
       Thread rotate;     //用Thread类声明一个rotate对象
       Planet earth;
       double pointX[]=new double[360],
              pointY[]=new double[360];
       int width,height;
       int radius=120;
       HaveThreadFrame()
       {
           rotate=new Thread(this);
          earth=new Planet();
          setBounds(0,0,360,400);
          width=getBounds().width;
          height=getBounds().height;
          pointX[0]=0;
          pointY[0]=-radius;
          double angle=1*Math.PI/180;
         for(int i=0;i<359;i++)
          {
             pointX[i+1]=pointX[i]*Math.cos(angle)-Math.sin(angle)*pointY[i];
            pointY[i+1]=pointY[i]*Math.cos(angle)+pointX[i]*Math.sin(angle);
          }
         for(int i=0;i<360;i++)
          {
             pointX[i]=pointX[i]+width/2;
            pointY[i]=pointY[i]+height/2;
          }
         setLayout(null);
         setVisible(true);
         validate();
         addWindowListener(new WindowAdapter()
                            {
             public void windowClosing(WindowEvent e)
                               {
                                     System.exit(0);
                               }
                            }
                           );
         add(earth);
         earth.setLocation((int)pointX[0]-earth.getSize().width/2,
                               (int)pointY[0]-earth.getSize().height/2);
         earth.start();
        rotate.start();   //用rotate调用start方法
       }
      public void run()
       { int i=0;
         while(true)
          {
             i=(i+1)%360;
             earth.setLocation((int)pointX[i]-earth.getSize().width/2,
                                   (int)pointY[i]-earth.getSize().height/2);
             try{
                 Thread.sleep(100);
                }
             catch(InterruptedException e){}
          }
       }
      public void paint(Graphics g)
       {
          g.setColor(Color.red);
         g.fillOval(width/2-15,height/2-15,30,30);
       }
    }
    

    package lzy;
    
    import java.awt.*;
    public class Planet extends Panel implements Runnable
    {
       Thread moon;     //用Thread类声明一个moon对象
       Mycanvas yellowBall;
       double pointX[]=new double[360],
              pointY[]=new double[360]; //用来表示画布左上角端点坐标的数组
       int w=100,h=100;
       int radius=30;
       Planet()
       {
           setSize(w,h);
         setLayout(null);
         yellowBall=new Mycanvas();
         yellowBall.setColor(Color.yellow);
         add(yellowBall);
         yellowBall.setSize(12,12);
         yellowBall.setR(12/2);
         pointX[0]=0;
         pointY[0]=-radius;
         double angle=1*Math.PI/180;   //刻度为1度
         for(int i=0;i<359;i++)        //计算出数组中各个元素的值
         {
             pointX[i+1]=pointX[i]*Math.cos(angle)-Math.sin(angle)*pointY[i];
           pointY[i+1]=pointY[i]*Math.cos(angle)+pointX[i]*Math.sin(angle);
         }
         for(int i=0;i<360;i++)
         {
             pointX[i]=pointX[i]+w/2;    //坐标平移
           pointY[i]=pointY[i]+h/2;
         }
         yellowBall.setLocation((int)pointX[0]-yellowBall.getR(),(int)pointY[0]-yellowBall.getR());
         moon =new Thread(this); //创建 moon线程,当前面板做为该线程的目标对象
       }
      public void start()
       {
          try{
              moon .start();
             }
          catch(Exception exe){ }
       }
      public void paint(Graphics g)
       {
          g.setColor(Color.blue);
         g.fillOval(w/2-9,h/2-9,18,18);
       }
      public void run()
       {
          int i=0;
         while(true)
          {
             i=(i+1)%360;
             yellowBall.setLocation((int)pointX[i]-yellowBall.getR(),
    (int)pointY[i]-yellowBall.getR());
             try{
                 Thread.sleep(10); // Thread类调用类方法sleep使得线程中断10豪秒
                }
             catch(InterruptedException e){}
          }
       }
    }
    

    3.双线程接力。

    ²  实验要求:

    编写一个应用程序,除了主线程外,还有两个线程:first和second。first负责模拟一个红色的按钮从坐标(10,60)运动到(100,60);second负责模拟一个绿色的按钮从坐标(100,60)运动到(200,60)。

    MoveButtonMainClass.java

    package lzy;
    
    public class MoveButtonMainClass
    {
        public static void main(String args[])
       {
            new MoveButton();
       }
    }
    


    MoveButton.java

    package lzy;
    import java.awt.*;
    import java.awt.event.*;
    public class MoveButton extends Frame implements Runnable,ActionListener
    {
        Thread first,second;//用Thread类声明first,second两个线程对象
       Button redButton,greenButton,startButton;
       int distance=10;
       MoveButton()
       {
          first=new Thread(this); //创建first线程,当前窗口做为该线程的目标对象
          second=new Thread(this); //创建first线程,当前窗口做为该线程的目标对象
          redButton=new Button();
          greenButton=new Button();
          redButton.setBackground(Color.red);
          greenButton.setBackground(Color.green);
          startButton=new Button("start");
          startButton.addActionListener(this);
          setLayout(null);
          add(redButton);
          redButton.setBounds(10,60,15,15);
          add(greenButton);
          greenButton.setBounds(100,60,15,15);
          add(startButton);
          startButton.setBounds(10,100,30,30);
          setBounds(0,0,300,200);
          setVisible(true);
          validate();
          addWindowListener(new WindowAdapter()
                            {
                                   public void windowClosing(WindowEvent e)
                               {
                                        System.exit(0);
                               }
                            }
                           );
       }
       public void actionPerformed(ActionEvent e)
       {
           try{
                first.start();
                second.start();
             }
          catch(Exception exp){}
       }
       public void run()
       {  while(true)
          {  if(Thread.currentThread()==first) //判断当前占有CPU资源的线程是否是first
              {   moveComponent(redButton);
                  try{ Thread.sleep(20);
                     }
                  catch(Exception exp){}
              }
             if(Thread.currentThread()==second) //判断当前占有CPU资源的线程是否是second
              {   moveComponent(greenButton);
                   try{ Thread.sleep(10);
                     }
                   catch(Exception exp){}
              }
          }
       }
       public synchronized void moveComponent(Component b)
       {
          if(Thread.currentThread()==first)
              {   while(distance>100&&distance<=200)
                   try{ wait();
                      }
                  catch(Exception exp){}
                  distance=distance+1;
                  b.setLocation(distance,60);
                  if(distance>=100)
                   {  b.setLocation(10,60);
                      notifyAll();
                   }
              }
          if(Thread.currentThread()==second)
              {
              while(distance>=10&&distance<100)
                   try{ wait();
                      }
                  catch(Exception exp){}
                  distance=distance+1;
                  b.setLocation(distance,60);
                  if(distance>200)
                    {  distance=10;
                       b.setLocation(100,60);
                       notifyAll();
                    }
              }
       }
    }
    



    展开全文
  • java实验多线程与异常处理

    千次阅读 2018-10-11 22:46:50
    实验目的:   了解线程的概念、线程的生命周期,掌握多线程的编程。...掌握利用Java语言编写多线程程序的方法 掌握线程的调度方法 编写一个程序,用来捕获各种类型的异常 编写一个程序,用来说明...
    • 实验目的:

     

    了解线程的概念、线程的生命周期,掌握多线程的编程。掌握异常的概念以及如何定义、抛出和捕捉处理异常。 

     

    二、实验环境:

     

    一台配置有java环境,装有eclipse的电脑。

     

    三、实验内容:

    (写出主要的内容)

    (一) 实验要求

    1. 掌握利用Java语言编写多线程程序的方法
    2. 掌握线程的调度方法
    3. 编写一个程序,用来捕获各种类型的异常
    4. 编写一个程序,用来说明异常处理块中各个语句块的作用
    5. 熟悉异常的类型及其产生的原因

    (二) Thread子类的方法实现多线程

    1. 编写 TwoThreadsTest.java 程序文件,源代码如下。

    class SimpleThread extends Thread {

         public SimpleThread(String str) {

             super(str);

         }

         public void run() {

             for (int i = 0; i < 10; i++) {

                 System.out.println(i + " " + getName());

                 try {

                     sleep((int)(Math.random() * 1000));

                 } catch (InterruptedException e) {}

             }

             System.out.println("DONE! " + getName());

         }

     }

    public class TwoThreadsTest {

         public static void main (String[] args) {

             new SimpleThread("Go to Beijing??").start();

             new SimpleThread("Stay here!!").start();

          }

         }

    1. 编译、运行
    2. 请将程序的运行结果写在实验报告中。

    (三)实现Runnable接口的方法实现多线程

      1. 程序功能:一个时钟Applet,它显示当前时间并逐秒进行更新
      2. 编写Clock.java 程序文件,源代码如下。

    import java.awt.*;

     import java.applet.*; 

     import java.util.*;

     public class Clock extends Applet implements Runnable{

            Thread clockThread;

            public void start(){

                   if(clockThread==null){

                          clockThread=new Thread(this,"Clock");

                          clockThread.start();

                   }

            }

            public void run(){

                   while(clockThread !=null){

                          repaint();

                          try{

                                 clockThread.sleep(1000);

                          }catch(InterruptedException e){}

                       }

            }

            public void paint(Graphics g){

                     Date now=new Date(); g.drawString(now.getHours()+";"+now.getMinutes()+";"+now.getSeconds(),5,10);

            }

            public void stop(){

                   clockThread.stop();

                   clockThread=null;

            }

         }

    3.编译Clock.java 文件。

        

    4.编写Clock.html 文件,源代码如下:
    <HTML>

    <HEAD>

    <TITLE> A Simple Program </TITLE>

    </HEAD>

    <BODY>

    Here is the output of my program:

    <APPLET CODE="Clock.class" WIDTH=150 HEIGHT=25>

    </APPLET> 

    </BODY>

    </HTML>

    1. 在浏览器中打开Clock.html 文件,将你看到的运行结果写在实验报告中。

    (四)捕获并处理各种类型的异常

    1.编写ExceptionTest.java 程序文件,源代码如下。
     import java.io.*;
     public class ExceptionTest{
            public static void main(String args[]) {
                   for(int i = 0; i < 4;i++) {
                          int k;
                          try {
                                switch( i ) {
                                        case 0:        
                                               int zero = 0;
                                               k = 911 / zero;
                                               break;
                                        case 1:      
                                               int b[ ] = null;
                                               k = b[0];
                                               break;
                                        case 2:      
                                               int c[ ] = new int[2];
                                               k = c[9];
                                               break;
                                        case 3:      
                                               char ch = "abc".charAt(99);
                                               break;
                                 }
                          }catch(Exception e) {
                                 System.out.println("\nTestcase #" + i + "\n");
                                 System.out.println(e);
                          }
                   }
            }
     }

    2. 编译、运行

    3. 根据运行结果,请在实验报告中说明程序运行中总共捕捉了几个异常,并指出每个异常各自属于哪种类型的异常?

    答:捕捉到四个异常。

    Testcase #0

    java.lang.ArithmeticException: / by zero  除数为0

    Testcase #1

    java.lang.NullPointerException  属于空指针异常

    Testcase #2

    java.lang.ArrayIndexOutOfBoundsException: 9   属于数组下标9越界异常

    Testcase #3

    java.lang.StringIndexOutOfBoundsException: String index out of range: 99  属于字符串异常

    (五)了解异常处理模块中各个语句块的功能

    1.编写TryTest.java 程序文件,源代码如下。

     import java.io.*; 
     public class TryTest{
            public TryTest(){                        
                   try{
                          int a[] = new int[2];
                          a[4] = 3;
                          System.out.println("After handling exception return here?");
                   }catch(IndexOutOfBoundsException e){
                          System.err.println("exception msg:" + e.getMessage());
                          System.err.println("exception string:" + e.toString());
                          e.printStackTrace();
                   }finally{
                          System.out.println("-------------------");
                          System.out.println("finally");
                   }
                   System.out.println("No exception?");
            }
            public static void main(String args[]){
                   new TryTest();
            }
     } 

    2. 编译、运行

    3. 根据运行结果,将程序的运行结果写在实验报告中。

    4. 请在实验报告中指出程序中的语句System.out.println("After handling exception return here?"); 有没有被执行?

     

    (六)思考题

    1. 简述并区分程序、进程和线程三个概念。

    答:①程序是为完成特定任务、用某种语言编写的一组指令的集合。指一段静态的代码。

    ②进程是程序的一次执行过程,是系统进行调度和资源分配的一个独立单位。

    ③线程是比进程更小的执行单位。

    一个进程在其执行过程中,可以产生多个线程,形成多条执行线索。

    每个线程也有它自身的产生、存在和消亡的过程,也是一个动态的概念。

    一个线程有它自己的入口和出口,以及一个顺序执行的序列

    线程不能独立存在,必须存在于进程中。

    1. 线程有哪几个基本的状态?Java中线程调度遵循何种原则?

    答:线程的基本状态有新建、就绪、运行、阻塞、死亡。线程调度安照线程的优先级来调度线程的执行,具有高优先级的线程会在较低优先级的线程之前得到执行。同时线程的调度是抢先式的。

    1. 实现多线程可以用哪两种基本方法?将这两种方法进行比较。

    答:第一种方法是通过实现Runnable接口实现,第二种方法是通过继承Thread类,

     

    使用Runnable方式可以实现两条线程交替运行(注:不是绝对的交替),而用Thread无法实现。

    1. 异常是如何抛出、捕捉和处理的?

    答:

    1. 异常处理机制有哪些好处?

    答:通过异常处理,我们可以对用户在程序中的非法输入进行控制和提示,以防程序崩溃。

    展开全文
  • 运用多线程技术,练习Thread类得run方法和start方法。运用进度条显式表示下载进度。java多线程之赛马程序
  • java 多线程实验

    2012-05-28 10:14:49
    java多线程实验源代码内蒙古科技大学计算机科学与技术
  • Java实验指导书_多线程 《Java语言程序设计基础教程》 上机实验指导手册 异常处理 【目的】 ①线程的创建和运行 ②Thread类的sleep、join等方法的使用 ③线程同步
  • 成绩 面向对象原理与Java实践课程实验报告 实验5多线程 姓 名 _ _ _ 班 级 _ 学 号 _ 实验地点 _ 实验时间 _ 指导教师 _ _ _ 一实验目的 了解线程调度机制 理解线程同步机制 掌握线程设计方法 二实验要求 掌握线程...
  • java多线程实验

    2013-06-20 13:36:55
    java设计两个线程,一个线程充当电子表,每隔一秒在窗口上显示一下系统时间;另一个线程充当闹钟,每到整点就开始报时,即在窗口显示5次整点提示,同时将第一个线程挂起,报时完毕后再将第一个线程恢复。实验结果如...
  • java多线程实验报告

    2020-11-07 10:06:39
    1. 应用图形用户接口和多线程的知识,编写一个应用程序实现下述功能:当单击“开始”按钮时随机产生一个两位整数不断在文本框上显示(每隔300毫秒显示一次),当单击“停止”按钮时,停止显示并将当前产生的数显示在...
  • java,多线程实验.zip

    2021-06-16 15:55:13
    java,多线程实验.zip
  • Java实验五——多线程实验

    千次阅读 2019-05-04 22:51:03
    1、练习多线程类的两种实现方法,理解多线程程序的生命周期。 二、实验内容 编写一多线程程序,实现如下功能: (1)一个线程进行阶乘和的运算(1!+2!+3!……+30!), 每次阶乘计算时间随机间隔0.5-1秒; (2)...
  • Java基础 实验多线程

    千次阅读 2019-01-12 20:22:51
    一、实验内容  在一个线程中求100以内素数,求出后休眠一个随机时间。在另一线程中求100以内能被3整除的数,求出后休眠一个随机时间。输出数据时应有提示,指明哪个线程输出的数据。 二、实验代码 1、...
  • java实验报告(多线程的应用)

    千次阅读 2020-01-11 09:50:07
    实验名称: 多线程的应用 实验地点: 所使用的工具软件及环境: 环境:Windows 8.1;jdk 1.8; 工具:eclipse 实验目的: 掌握线程的生命周期及状态迁移,学会如何创建线程,掌握线程的调度策略,线程优先级和线程同步 ...
  • Java多线程实验

    2015-10-03 21:59:22
    多线程是比较抽象的一个概念,其实多线程是一种运筹,单线程就像一次只干一件事情,一件事情做完再去做接下来的另外一件事,比如先煮饭,等饭熟了再炒菜。而多线程则是饭还在煮着的同时就炒菜,然后饭菜差不多同时好...
  • 1.编写一个应用程序实现下述功能:当单击“开始”...2.修改课件中例题Example9_2.java,当点击“开始计时”按钮时,文本框中显示当前的年月日和时分秒,并且当文本框下移到窗体底部时,自动跳到窗体的顶端继续显示。
  • 武汉理工大学Java多线程实验源码,大二上Java实验源码。
  • java实验三 多媒体和多线程处理

    千次阅读 2019-02-21 12:47:47
    学院 计算机科学与教育软件学院 年级、专业、班 网络16* 姓名 ... 实验课程名称 ... Java语言实验 成绩   ...
  • 实验八:Java多线程

    2011-07-14 00:21:06
    本次实验了解线程与进程的概念、区别与联系,掌握了多线程的内涵与使用场景,掌握了线程的状态与生命周期,掌握了Java实现多线程的两种方式,理解了临界区、对象锁、互斥、同步等核心概念,理解了线程的互斥与同步,...
  • 一、实验目的: 了解... 二、实验环境: Eclipse 三、实验内容:(一)Thread子类的方法实现多线程 编写 TwoThreadsTest.java 程序文件,源代码如下:class SimpleThread extends Thread { public SimpleThrea...
  • JAVA多线程实验报告

    2008-12-10 13:58:10
    利用多线程技术编写applet程序。其中包含一个滚动的字符串,字符串从左向右移动,当所有的字符都从屏幕的右边消失后,字符串重新从左边出现并继续向右移动
  • 关于java多线程技术的实验 掌握java语言中的多线程编程技巧 掌握Thread类和Runnable接口 掌握java语言中多线程的生命周期 掌握java语言中线程的通信技巧

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 46,111
精华内容 18,444
关键字:

java实验10多线程

java 订阅