8-实验八Java多线程操作(实验报告内容)

合集下载

多线程程序实验报告(3篇)

多线程程序实验报告(3篇)

第1篇一、实验目的1. 理解多线程的概念和作用。

2. 掌握多线程的创建、同步和通信方法。

3. 熟悉Java中多线程的实现方式。

4. 提高程序设计能力和实际应用能力。

二、实验环境1. 操作系统:Windows 102. 开发工具:IntelliJ IDEA3. 编程语言:Java三、实验内容本次实验主要完成以下任务:1. 创建多线程程序,实现两个线程分别执行不同的任务。

2. 使用同步方法实现线程间的同步。

3. 使用线程通信机制实现线程间的协作。

四、实验步骤1. 创建两个线程类,分别为Thread1和Thread2。

```javapublic class Thread1 extends Thread {@Overridepublic void run() {// 执行Thread1的任务for (int i = 0; i < 10; i++) {System.out.println("Thread1: " + i);}}}public class Thread2 extends Thread {@Overridepublic void run() {// 执行Thread2的任务for (int i = 0; i < 10; i++) {System.out.println("Thread2: " + i);}}}```2. 创建一个主类,在主类中创建两个线程对象,并启动它们。

```javapublic class Main {public static void main(String[] args) {Thread thread1 = new Thread1();Thread thread2 = new Thread2();thread1.start();thread2.start();}```3. 使用同步方法实现线程间的同步。

```javapublic class SynchronizedThread extends Thread {private static int count = 0;@Overridepublic void run() {for (int i = 0; i < 10; i++) {synchronized (SynchronizedThread.class) {count++;System.out.println(Thread.currentThread().getName() + ": " + count);}}}}public class Main {public static void main(String[] args) {Thread thread1 = new SynchronizedThread();Thread thread2 = new SynchronizedThread();thread1.start();thread2.start();}```4. 使用线程通信机制实现线程间的协作。

java多线程程序设计实验总结

java多线程程序设计实验总结

java多线程程序设计实验总结一、实验目的本次实验旨在通过编写Java多线程程序,掌握多线程编程的基本概念和技能,理解多线程程序的运行原理,提高对Java语言的熟练度。

二、实验内容本次实验分为三个部分:创建线程、线程同步和死锁。

2.1 创建线程创建线程有两种方式:继承Thread类和实现Runnable接口。

继承Thread类需要重写run方法,在run方法中编写线程执行的代码;实现Runnable接口需要实现run方法,并将其作为参数传入Thread类的构造函数中。

在创建多个线程时,可以使用同一个Runnable对象或者不同的Runnable对象。

2.2 线程同步当多个线程同时访问共享资源时,可能会出现数据不一致等问题。

为了避免这种情况,需要使用同步机制来保证各个线程之间的协调运行。

常见的同步机制包括synchronized关键字和Lock接口。

synchronized关键字可以用来修饰方法或代码块,在执行该方法或代码块时,其他所有试图访问该方法或代码块的线程都必须等待当前执行完成后才能继续执行。

Lock接口提供了更加灵活和高级的锁机制,可以支持更多种类型的锁,如读写锁、可重入锁等。

2.3 死锁死锁是指两个或多个线程在互相等待对方释放资源的情况下,都无法继续执行的现象。

死锁的发生通常由于程序设计不当或者资源分配不合理所导致。

为避免死锁的发生,可以采取以下措施:避免嵌套锁、按照固定顺序获取锁、避免长时间占用资源等。

三、实验过程本次实验我编写了多个Java多线程程序,包括创建线程、线程同步和死锁。

其中,创建线程部分我使用了继承Thread类和实现Runnable 接口两种方式来创建线程,并测试了多个线程之间的并行执行情况;在线程同步部分,我使用synchronized关键字和Lock接口来保证共享资源的访问安全,并测试了多个线程同时访问共享资源时是否会出现数据不一致等问题;在死锁部分,我编写了一个简单的死锁程序,并通过调整程序代码来避免死锁的发生。

第8次实验:多线程

第8次实验:多线程

第八次实验:多线程开发一、实验目的了解线程的概念、线程的生命周期,掌握多线程的编程。

掌握框架的使用,掌握字符流的使用。

二、实验要求1.掌握利用Java语言编写多线程程序的方法2.掌握线程的调度方法3.掌握图形界面设计中框架的使用4.编写一个程序,用来进行字符流的输入/输出三、实验内容(一)继承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();}}2.编译、运行3.请将程序的运行结果写在实验报告中。

(二)实现Runnable接口的方法实现多线程1.编写KY8_2.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;}}1.编译并运行,请将程序的运行结果写在实验报告中。

Java多线程实验报告

Java多线程实验报告

实验报告课程名称: Java语言程序设计姓名:学号:班级:数学与计算机科学学院数学与计算机科学学院实验报告实验名称:多线程指导教师:日期:if (isPrime)count++;}System.out.println(st + "~" + en + "之间共有" + count + "个质数");}public static void main(String[] args) {UseThread thread1 = new UseThread(2, 1000);UseThread thread2 = new UseThread(1000, 2000);thread1.start();thread2.start();}}第2题代码:public class Experiment14_2 {public static void main(String[] args) {MyThread t1 = new MyThread("T1");MyThread t2 = new MyThread("T2");t1.start();t2.start();System.out.println("活动线程数:" + Thread.activeCount());System.out.println("main()运行完毕");}}class MyThread extends Thread {public MyThread(String s) {super(s);}public void run() {for (int i = 1; i <= 3; i++) {System.out.println(getName() + "第" + i + "次运行");try {sleep((int) (Math.random() * 100));} catch (InterruptedException e) {e.printStackTrace();}}System.out.println(getName() + "结束");}}实验结果第1题第2题:。

【实验】java多线程实验报告

【实验】java多线程实验报告

【关键字】实验java多线程实验报告篇一:西北农林科技大学java多线程实验报告实验7 多线程1.实验目的(1) 掌握Java多线程的概念和实现方法(2) 掌握Java多线程的同步问题2.实验内容任务一:火车售票假设有火车票1000张,创建10个线程模拟10个售票点,每个售票点100毫秒买一张票。

打印出售票过程,注意使用synchronized确保同一张票只能卖出一次。

程序运行结果见左图。

打开EclipseTickets.javapublic class Ticket extends Thread {int ticket =1000; String name =""; public void run(){ while(true){synchronized(name){ if(ticket"第" + Thread.currentThread().getName()+ "售票点卖出了第" + ticket-- + "张票");}} }}} try{ } catch(InterruptedException e){ } Thread.sleep(100);Test.javapublic class Test {} public static void main(String args[]){} Ticket t = new Ticket(); new Thread(t,"1").start(); new Thread(t,"2").start(); new Thread(t,"3").start(); new Thread(t,"4").start(); new Thread(t,"5").start(); new Thread(t,"6").start(); new Thread(t,"7").start(); new Thread(t,"8").start(); new Thread(t,"9").start(); new Thread(t,"10").start();任务二:银行存款假设某家银行,它可接受顾客的汇款,每做一次汇款,便可计算出汇款的总额。

java多线程的实验报告

java多线程的实验报告

java多线程的实验报告Java多线程的实验报告一、引言多线程是计算机科学中一个重要的概念,它可以提高程序的并发性和效率。

Java作为一种广泛应用的编程语言,也提供了丰富的多线程支持。

本实验旨在通过编写多线程程序,探索Java多线程的特性和使用方法。

二、实验目的1. 理解多线程的概念和原理;2. 掌握Java多线程的基本使用方法;3. 分析多线程程序的执行过程和效果。

三、实验过程1. 创建多线程在Java中,可以通过继承Thread类或实现Runnable接口来创建多线程。

本实验选择实现Runnable接口的方式。

首先,定义一个实现了Runnable接口的类MyThread,重写run()方法,在该方法中编写线程的具体逻辑。

2. 启动多线程在主线程中,创建MyThread对象,并通过Thread类的构造函数将其作为参数传入。

然后,调用Thread类的start()方法启动线程。

3. 线程同步在多线程程序中,为了避免线程之间的数据竞争和冲突,需要进行线程同步。

Java提供了synchronized关键字和Lock接口来实现线程同步。

本实验使用synchronized关键字来保证线程的安全性。

4. 线程通信多线程之间的通信可以通过共享变量、wait()和notify()方法来实现。

本实验通过共享变量来实现线程通信,其中一个线程负责生产数据,另一个线程负责消费数据。

5. 线程池Java提供了Executor框架来管理线程池。

通过使用线程池,可以减少线程的创建和销毁开销,提高程序的性能。

本实验使用Executor框架来管理线程池,并设置合适的线程数量。

四、实验结果通过以上实验过程,成功实现了多线程程序,并观察到了以下结果:1. 多线程的执行顺序是不确定的,不同线程的执行顺序可能不同;2. 多线程程序可以提高程序的并发性和效率;3. 线程同步能够保证多线程程序的安全性;4. 线程通信可以实现多线程之间的数据交换和协作;5. 使用线程池可以提高程序的性能。

java 实验八 多线程 实验报告

java 实验八 多线程 实验报告

实验八多线程实验目标:(1)掌握使用Thread的子类创建线程;掌握实现Runable接口来实现多线程;(2)掌握线程之间的数据共享;(3)掌握线程之间的同步方法;(4)掌握线程之间的通信方法。

实验任务:1、选择答题(请将答案标成红色,如(AB)):1.下面关于线程的说法正确的是( ABD )。

A)Java 支持多线程机制。

B)一个线程创建并启动后,它将执行自己的run()方法,如果通过派生Thread类实现多线程,则需要在子类中重新定义run()方法,把需要执行的代码写run()方法中;如果通过实现Runnable接口实现多线程,则要编写run()方法的方法体。

C)要在程序中实现多线程,必须导入Thread类: import ng.Thread;D)一个程序中的主类不是Thread的子类,该类也没有实现Runnable接口,则这个主类运行是不能控制主线程的休眠。

2.如果程序中创建了两个线程,一个的优先级是Thread.MAX_PRIORITY,另一个的优先级是正常的默认优先级,下列陈述哪个是对的?( A)A)正常优先级的线程不运行,直到拥有最高优先级的线程停止运行。

B)即使拥有最高优先级的线程结束运行,正常优先级的线程也不会运行。

C)正常优先级的线程优先运行。

D)上述说法都不对。

3.下面哪个是Runnable接口中的抽象方法( D)?A)start B)stop C)yield D)run4.编译下面的程序,得到的结果是( C)。

public class A implements Runnable {public void run () {System.out.println("OK.");}public static void main (String[] args) {Thread Th=new Thread (new A());Th.start();}}A)程序不能编译,产生异常。

实验八:Java多线程(bo)

实验八:Java多线程(bo)

实验八Java多线程【实验目的】1)掌握线程与进程的概念、区别与联系2)掌握多线程的内涵与使用场景3)掌握线程的状态与生命周期4)掌握Java实现多线程的两种方式5)掌握临界区、对象锁、互斥、同步等核心概念6)掌握线程的互斥与同步7)了解线程的死锁【实验环境】JDK1.6+Eclpise3.2【实验准备】1)复习课件中理论知识2)练习课堂所讲的例子【实验内容】选择两个城市作为预选旅游目标,实现两个独立的线程分别显示10次城市名,每次显示后休眠一段随机时间(1000毫秒以内),哪个先显示完毕,就决定去哪个城市。

【实验过程及结果】package eight;public class MainThread {public static void main(String[] args) {String[]citys={"安阳","开封"};City1 thread1=new City1(citys);City2 thread2=new City2(citys);thread1.start();thread2.start();while(thread1.isAlive()==true||thread2.isAlive()==true){try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}if(thread1.getTime()<thread2.getTime()){System.out.println("决定去:"+citys[0]);}else{System.out.println("决定去:"+citys[0]);}}}CITY1package eight;public class City1 extends Thread {private String[] citys;private long time;public long getTime(){return time;}public City1 (String[] citys) {this.citys=citys;}public void run(){long start=System.currentTimeMillis();for(int i=0;i<10;i++){try{System.out.println("Thread1"+citys[0]);Thread.sleep((int)(Math.random()*1000));}catch(Exception e){}}time=System.currentTimeMillis()-start;System.out.println("Thread1 Ends!共花费了"+time+"ms");}}CITY2package eight;public class City2 extends Thread {private String[] citys;private long time;public City2 (String[] citys) {this.citys=citys;}public long getTime(){return time;}public void run(){long start=System.currentTimeMillis();for(int i=0;i<10;i++){try {System.out.println("Thread2"+citys[0]);Thread.sleep((int)(Math.random()*1000));} catch (InterruptedException e) {e.printStackTrace();}}time=System.currentTimeMillis()-start;System.out.println("Thread2 Ends!共花费了"+time+"ms");}}实验结果:【实验感想】通过这次实验我明白了多线程的使用以及runrable 和thread 类的使用各有什么意思,线程的状态等,以及线程与程序的含义,单线程与多线程的不同,在动手实践中,比较直观的看到多线程的运行过程和最终结果,体会线程抽象的含义及其衍生定义。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

实验八 Java多线程操作
(实验报告)
一、目的
1.掌握Java多线程操作。

二、实验内容
启动线程,线程休眠,线程同步,等待和唤醒
三、实验环境
JDK1.6+dos环境
四、实验原理
通过案例掌握多线程操作。

五、实验步骤
1、设计一个线程操作类,要求可以产生三个线程对象,并可以分
别设置三个线程的休眠时间,如下所示:
线程A,休眠10秒
线程B,休眠20秒
线程C,休眠30秒
2、生产者与消费者问题,生产者生产一台电脑,消费者马上将生
产出的电脑取走。

六、实验小结
1、class MyThread implements Runnable{
String name;
int time;
public MyThread(String name,int time){
=name;
this.time=time;
}
public void run(){
try{
Thread.sleep(this.time);
}
catch(Exception e){
}
System.out.println(+"线程,休眠"+this.time/1000+"秒");
}
}
public class Demo08{
public static void main(String args[]){
MyThread mt1=new MyThread("线程A",10000);
MyThread mt2=new MyThread("线程B",20000);
MyThread mt3=new MyThread("线程C",30000);
new Thread(mt1).start();
new Thread(mt2).start();
new Thread(mt3).start();
}
}
//生产电脑和搬运电脑
class Computer{
private String name;
public static int sum=0;
private boolean flag=true;
public Computer(String name){
=name;
}
public synchronized void set(){ //生产电脑if(!flag){
try{
super.wait();
}
catch(Exception e){
e.printStackTrace();
}
}
sum=sum+1;
System.out.println("第"+sum+"台"+name+"电脑被生产");
flag=false;
super.notify();
}
public synchronized void get(){ //搬走电脑
if(flag){
try{
super.wait();
}
catch(Exception e){
e.printStackTrace();
}
}
System.out.println("第"+sum+"台"+name+"电脑被搬走");
flag=true;
super.notify();
}
}
class Producter implements Runnable{ private Computer c=null;
public Producter(Computer c){
this.c=c;
}
public void run(){
for(int i=0;i<1000;i++){
this.c.set();
}
}
}
class Worker implements Runnable{ private Computer c=null;
public Worker(Computer c){
this.c=c;
}
public void run(){
for(int i=0;i<1000;i++){
this.c.get();
}
}
}
public class Test{
public static void main(String args[]){ Computer c=new Computer("联想");
Producter p=new Producter(c);
Worker w=new Worker(c);
new Thread(p).start();
new Thread(w).start();
}
}。

相关文档
最新文档