实验6 多线程

一、实验名称和性质

所属课程 实验名称 实验学时 实验性质 必做/选做 二、实验目的

1. 理解线程概念；了解线程的状态和生命周期； 2. 学习继承Thread类来创建线程；

3. 理解线程互斥与同步的含义；掌握Synchrnized同步方法。

三、实验内容

1．设计一个包含多线程运行的程序，在主程序中依次创建3个线程，然后按顺序启动这3个线程，每个线程在执行时都是先睡眠(sleep)一会儿，醒来之后再继续执行(验证性实验)。

2．用程序模拟铁路火车票售票系统，实现通过3个售票窗口同时发售某次列车的100张车票。程序中会有3个线程同时对同一个车票对象进行操作，每个线程的操作都按相同的步骤进行，即将当前车票数加1，然后将当前车票数与剩余车票数显示出来。由于车票数是临界资源，一次只能有一个线程完成读写操作，因此必须处理好线程之间的互斥关系（设计性实验）。

四、实验的软硬件环境要求

硬件环境要求：

PC计算机；内存512MB以上 使用的软件名称、版本号以及模块：

操作系统：Windows 2000或Windows XP

软件：JDK7.0；Ecliplse 五、知识准备

前期要求掌握的知识：了解Java程序的运行流程。

实验相关理论或原理：多线程是指一个程序中可以包含两个或两个以上同时并发运行的程序单元，每个程序单元称之为一个线程。Java为多线程编程提供了语言级的支持，因此可以编写高效率的程序。

一个线程从它被创建到运行结束的过程，称为线程的生命周期。在Java中使用多线程有如下两种方式：一是继承Thread线程类，第二是实现Runnable接口。在Thread类中有两个主要的方法，一个是run()方法，另一个是start()方法，在Thread类的派生类中要覆盖这个run()方法，将多线程代码放入其中。Start()方法的作用是启动一个线程，它会自动地去调用run()方法以执行该线程。

为了使多个线程互斥地使用临界资源，可以在临界资源上使用synchrnized修饰符。 六、验证性实验

Java语言程序设计 多线程设计 4 ✓验证 综合✓设计 ✓必做 选做 1．实验要求

编译、运行ThreeThreads.java程序，运行结果如图7.1所示。

图7.1 验证性实验运行结果

2．源程序代码参考

class MyThread extends Thread { public MyThread(String name) { super(name); }

public void run() {

//让线程进入休眠状态，休眠指定的时间 int sleeptime=100; try {

System.out.println(getName() + \" 将休眠\" + sleeptime + \"毫秒\"); Thread.sleep(sleeptime) ; //休眠 } catch (InterruptedException ex) { ex.printStackTrace(); }

System.out.println(getName() + \" 结束休眠\"); } }

public class ThreeThreads {

public static void main(String[] args) {

MyThread thread1 = new MyThread(\"线程1\"); MyThread thread2 = new MyThread(\"线程2\"); MyThread thread3 = new MyThread(\"线程3\");

thread1.start(); thread2.start(); thread3.start(); }

}

运行结果：

线程2 将休眠100毫秒 线程1 将休眠100毫秒 线程3 将休眠100毫秒 线程3 结束休眠 线程1 结束休眠 线程2 结束休眠

七、设计性实验

1． 编译、运行程序TestSaleTicket.java ,结果如图7.2所示。

图7.2 设计性实验运行结果

class Ticket { //车票类 int curticket; //当前票数 int ticketCount; //总票数 public Ticket(int curticket, int ticketCount) { this.curticket = curticket; this.ticketCount = ticketCount; } }

class SaleTicket implements Runnable { //售票类

private Ticket t;

public SaleTicket(Ticket t){ this.t = t; }

public void run(){ while(true){

synchronized(this){

if(t.curticket < t.ticketCount){ try{

Thread.sleep(50); }

catch(InterruptedException ex){ }

t.curticket++;

System.out.println(Thread.currentThread().getName() + \"正在销售第\" + t.curticket + \"张票，剩余票数：\" + (t.ticketCount - t.curticket)); } else{

break; } } } }

}

public class TestSaleTicket { //测试类

public static void main(String[] args) { Ticket t = new Ticket(0, 100); SaleTicket st = new SaleTicket(t);

Thread win1 = new Thread(st, \"售票窗口1\");

Thread win2 = new Thread(st, \"售票窗口2\"); //实例化线程对象窗口1 Thread win3 = new Thread(st, \"售票窗口3\"); //实例化线程对象窗口2 win1.start(); win2.start(); win3.start(); } }

运行结果：

2. 编写程序，启动1000个线程。每个线程给初始值为0的变量total加1。通过引用传递的方式将total传递给每个线程。使用同步和不同步来运行这个程序，看看他们的效果。 提示：为了能够进行引用传递，需要定义包装对象来保存total变量。

代码： 同步：

package experimentSix;

public class TestThread1 {

private static Account account = new Account();

class Add implements Runnable{ public void run(){ account.add(); } }

private static class Account{ public static int total = 0; public int getTotal(){ return total; }

public synchronized void add(){ try{

Thread.sleep(5); }

catch(InterruptedException ex){ }

total++;

System.out.println(account.getTotal()); }

}

public static void main(String[] args){ for(int i = 0 ; i < 1000 ; i++){

new Thread(new TestThread1().new Add()).start(); } } }

运行结果：

不同步：

package experimentSix;

public class TestThread {

public static int total = 0;

class Add implements Runnable{ public void run(){ total++;

System.out.println(total); } }

public static void main(String[] args){ for(int i = 0 ; i < 1000 ; i++){

new Thread(new TestThread().new Add()).start(); } }

}

运行结果：

效果：使用同步可以避免数据不一致的问题，未使用同步有数据不一致的问题

实验总结：

经过这次实验，初步了解了线程的相关用法，但在使用过程中并不熟悉，实践过程遇到较多问题，需要进一步学习了解；对线程的概念理解不到位，需要进一步理解。在编程的时候，例如写售票的那个程序，大概知道要补充的是什么内容，开始有点无从下手，具体的编写总有遗漏和其他问题。