实验七：多线程编程

实验目的：

（1）了解进程和线程的概念
（2）了解多线程编程的特点
（3）利用Thread类和Runnable接创建多线程类
（4）掌握线程类的常用方法
（5）掌握多线程同步的方法

实验内容：

1、利用多线程类实现20个偶数和20个奇数的随机输出。
2、利用多线程编程实现多个窗口卖票的问题：
（1）三个窗口同时各卖10张票；
（2）三个窗口共同卖10张票。
3、编写多线程程序，实现生产者、消费者线程，并实现线程的同步：
（1）生产者线程产生20个数，消费者线程输出生产者线程产生的这20个数。
（2）使用线程的同步与协调机制使二者达到如此效果：产生一个数，取出一个数。

1、利用多线程类实现20个偶数和20个奇数的随机输出。

package cn.edu.sdut.acm;
// 线程类
public class MyThread extends Thread{
    boolean flag = false;

    @Override
    public void run() {
        if (flag){
            for (int i = 1; i < 40; i = i+2) {
                System.out.println("-----"+i);
            }
        }else{
            for (int i = 2; i <= 40; i += 2){
                System.out.println(i+"----");
            }
        }
    }
}

package cn.edu.sdut.acm;
// 主函数
class Main{
    public static void main(String[] args) {
        MyThread mt1 = new MyThread();
        mt1.flag = true;

        MyThread mt2 = new MyThread();
        mt2.flag = false;

        mt1.start();
        mt2.start();
    }
}

2、利用多线程编程实现多个窗口卖票的问题：

（1）三个窗口同时各卖10张票

package cn.edu.sdut.acm;

public class RunnableImpl implements Runnable{
    private int num = 10;

    @Override
    public void run() {
        // 设置线程任务
        while (num > 0){
            System.out.println(Thread.currentThread().getName()+"正在销售第"+num+"号票");
            num--;
        }
    }
}

package cn.edu.sdut.acm;

public class Main{
    public static void main(String[] args) {
        RunnableImpl r1 = new RunnableImpl();
        RunnableImpl r2 = new RunnableImpl();
        RunnableImpl r3 = new RunnableImpl();
        new Thread(r1, "一号售票窗口").start();
        new Thread(r2, "二号售票窗口").start();
        new Thread(r3, "三号售票窗口").start();
    }
}

（2）三个窗口共同卖10张票

package cn.edu.sdut.acm;

public class RunnableImpl implements Runnable{
    private int num = 10;
    Object obj = new Object();

    @Override
    public void run() {
        while (true){
            synchronized (obj){
                if (num > 0){
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+"正在销售第"+num+"号票");
                    num--;
                }
            }
        }
    }
}

package cn.edu.sdut.acm;

public class Main{
    public static void main(String[] args) {
        RunnableImpl r = new RunnableImpl();

        Thread t1 = new Thread(r, "一号售票窗口");
        Thread t2 = new Thread(r, "二号售票窗口");
        Thread t3 = new Thread(r, "三号售票窗口");
        t1.start();
        t2.start();
        t3.start();
    }
}

3、编写多线程程序，实现生产者、消费者线程，并实现线程的同步：

（1）生产者线程产生20个数，消费者线程输出生产者线程产生的这20个数。

package cn.edu.sdut.acm;

import java.util.Random;

public class Main{
    static int[] temp = new int[20];
    public static void main(String[] args) {
        // 创建唯一的锁对象
        Object obj = new Object();

        new Thread(){
            @Override
            public void run(){
                synchronized (obj){
                    try {
                        obj.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    for (int i = 0; i < 20; i++){
                        System.out.println(temp[i]);
                    }
                }
            }
        }.start();
        new Thread(){
            @Override
            public void run(){
                synchronized (obj){
                    for (int i = 1; i <= 20; i++){
                        temp[i-1] = i;
                    }
                    obj.notify();
                }
            }
        }.start();

    }
}

（2）使用线程的同步与协调机制使二者达到如此效果：产生一个数，取出一个数。

package cn.edu.sdut.acm;

import java.util.Random;

public class Main{
    static int temp;
    public static void main(String[] args) {
        // 创建唯一的锁对象
        Object obj = new Object();
        // 创建临时变量
        new Thread(){
            @Override
            public void run(){
                synchronized (obj){
                    for (int i = 1; i <= 20; i++){
                        temp = i;
                        try {
                            obj.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }.start();

        new Thread(){
            @Override
            public void run(){
                while(true){
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (obj){
                        System.out.println("输出： "+temp);
                        if (temp < 20){
                            obj.notify();
                        }
                    }
                }
            }
        }.start();
    }
}