java多线程抽奖_Java多线程应用示例-抽奖

这里用java多线程实现一个简单的抽奖程序，从100个座位号中，随机抽取10位。

我设计的思路是用10个线程，每个线程从100个座位号中随机抽取1位，然后显示在黑板上，然后再去抽取，再显示。这里涉及到从100 个座位号中随机抽取时要线程之间要同步，否则会出现同一个号被多个线程抽取。一个线程大致分为如下几个步骤：

a.从待抽取的座位列表中随机抽取座位。

b.将抽取的座位号显示在黑板对应的位置上，并取得那个位置上当前显示的座位号。

c.将b步得到的座位号添加到待抽取列表中。

经过a,b,c三步，一个线程一次的动作算完成了，将这三步操作视为一个原子操作，进行线程间同步，剩下的就是循环抽取座位号就行了。

有几点需求注意：

1.b步可以不同步，但发现，当随机抽取的数量多时，此时一个线程(假设代号为1)还没有来得及更新黑板上对应位置的座位号，另一个线程(假设代号为2)已经将1线程放入座位组中的号又取出来，并显示在黑板上了。这样就会造成黑板上同一个座位号显示了多次。

2.需要区分哪些座位号是抽取过的，哪些座位号是没有抽取过的，这样每次抽取只抽取没有抽取过的。会自然而然的用两个List表示。但仔细想想，不需要用两个List区分，因为黑板上显示的座位号就是已经抽取的，只需要每次从座位池中删除，然后显示在黑板上，再次抽取时，将黑板上原来显示的座位号放回座位池中即可。

3.是否可以用LinkedList代替ArrayList。大家都知道LinkedList的删除，插入性能优于ArrayList,并且这里线程也需要反复不断的对座位池进行删除，新增操作。但这里的新增只是在最后面加入，影响不大，有影响的就是删除操作。但是这样还会有不断的随机取号操作。到底是删除操作影响大，还是取号操作影响大呢？经过验证发现，当座位池中座位号比较大时(假如为10万)，LinkedList速度会明显慢于ArrayList,几乎有10倍之差。

源码如下:

抽取号码部分:

package cn.yanggy.demo03;

import java.util.ArrayList;

import java.util.List;

import java.util.Random;

/**

* @author Cool-Coding 2017/12/1

* 此类是随机样本抽取工具类，从N个样本源中随机抽取M个样本

*由于N个样本不断的从队列取出，再放到队列尾部，N个样本抽中的概率相等

* 使用方法：

* RandomFetch randomFetch=new RandomFetch(source,sampleCount,SampleShow);

* randomFetch.start()

* randomFetch.stop()

* randomFetch.pause()

* randomFetch.resume()

*/

public final class RandomFetch {

//源数据池

private List source;

//样本数

private int smaple;

//结果回调接口

private SampleShow sampleShow;

//线程列表

private final List threadList = new ArrayList<>();

//停止标识，使用volatile，是因为多线程共享同一变量时，需要变量改变时，线程能够即时发现

private volatile boolean stop = false;

//暂停标识

private volatile boolean suspend = false;

//暂停锁

private Object suspendLock=new Object();

public RandomFetch(List source,int sample,SampleShow sampleShow) {

this.source=source;//源数据池

this.smaple=sample;//样本数

this.sampleShow=sampleShow;//结果回调接口

}

//开始抽奖

public void start() {

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

Picker runnable = new Picker();

threadList.add(runnable);

Thread thread = new Thread(runnable, i + "");

thread.start();

}

}

//停止抽奖

public void stop() {

stop = true;

}

//恢复

public void resume() {

suspend = false;

//threadList.forEach(pick ->{synchronized(pick){pick.notify();}});

synchronized (suspendLock){

suspendLock.notifyAll();

}

}

//暂停

public void pause() {

suspend = true;

}

//抽奖线程

private class Picker implements Runnable {

public T pickSeatNumber() {

//有待取的座位时才去取，否则跳过

int count = source.size();

if (count > 0) {

//随机取一个序号[0,count)

int index = new Random().nextInt(count);

//得到座位号

T seatNumber = source.get(index);

//将座位从待取座位中移除

source.remove(index);

return seatNumber;

}

return null;

}

public T showSeatNumber(T seatNumber) throws RandomFetchException {

//看当前线程更新的是黑板上哪个位置的座位号[0,sample)

int index = Integer.valueOf(Thread.currentThread().getName());

if(index >=0 && index < smaple) {

T oldSample=sampleShow.show(index,seatNumber);

//如果黑板对应位置之前没有座位号时，则返回Null

if (oldSample == null || oldSample.equals("")) oldSample = null;

return oldSample;

}else{

throw new RandomFetchException("thread name is not right,it should be between 0 and "+smaple);

}

}

public void readyAgain(T oldSeatNumber) {

//添加到待取座位列表中

source.add(oldSeatNumber);

}

@Override

public void run() {

while (!stop) {

if (suspend) {

//object.wait,object.notify必须是锁对象

//此处不用RandomFetch.this，原因是其它线程获得了RandomFetch.this锁时，当前

//线程仍可以暂停

synchronized (suspendLock) {

try {

suspendLock.wait();

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

synchronized (RandomFetch.this) {

T seatNumnber = pickSeatNumber();

T oldSeatNumber = null;

if (seatNumnber != null) {

try {

oldSeatNumber = showSeatNumber(seatNumnber);

}catch (RandomFetchException e){

e.printStackTrace();

}

}

if (oldSeatNumber != null) {

readyAgain(oldSeatNumber);

}

}

}

}

}

}

package cn.yanggy.demo03;

/**

* @author Cool-Coding 2017/12/1

* 异常类

*/

public class RandomFetchException extends Exception {

public RandomFetchException(){

}

public RandomFetchException(String message){

super(message);

}

}

package cn.yanggy.demo03;

/**

* @author Cool-Coding 2017/12/1

* 随机抽奖返回结果接口

* 此接口用于调用者与随机抽奖线程之间进行数据交换

*/

public interface SampleShow {

public T show(int index, T data);

}

屏幕部分:

package cn.yanggy.demo03;

import javax.swing.*;

import java.awt.*;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.util.ArrayList;

/**

* @author Cool-Coding 2017/12/1

*/

public class BlackBoard extends JFrame implements ActionListener {

private final int LUCKYCOUNT =10;

private final String START ="开始";

private final String STOP ="停止";

private final String PAUSE ="暂停";

private final String RESUME ="恢复";

private final JPanel panel=new JPanel(new GridLayout(5, 2));

private JButton jButton;

private JButton jButton2;

private final RandomFetch randomFetch;

public BlackBoard(){

// 窗口属性的设置

setTitle("抽奖");// 窗口标题

setSize(300, 200);// 窗口大小

setLocationRelativeTo(null);// 窗口居中

setDefaultCloseOperation(EXIT_ON_CLOSE);// 关闭窗口则退出虚拟机

setLayout(new GridLayout(2, 1));// 设置布局流式布局

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

final JLabel label=new JLabel();

label.setName(i+"");

label.setFont(new Font("宋休",Font.PLAIN,20));

panel.add(label);

}

JPanel panel2=new JPanel();

jButton=new JButton(START);

jButton.setSize(100,100);

jButton.addActionListener(this);

panel2.add(jButton);

jButton2=new JButton(PAUSE);

jButton2.setEnabled(false);

jButton2.setSize(100,100);

jButton2.addActionListener(this);

panel2.add(jButton2);

add(panel);

add(panel2);

//抽取样本

ArrayList source=new ArrayList<>();

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

source.add("seat"+i);

}

randomFetch = new RandomFetch(source, LUCKYCOUNT, new SampleShow() {

@Override

public String show(int index, String data) {

JLabel label=BlackBoard.this.getLabel(index);

String oldSeatNumber = label.getText();

label.setText(data);

return oldSeatNumber;

}

});

}

//获取Lable

public JLabel getLabel(int index){

return (JLabel)panel.getComponent(index);

}

@Override

public void actionPerformed(ActionEvent e) {

String action=e.getActionCommand();

if(action.equals(START)) {

randomFetch.start();

jButton.setText(STOP);

//可以暂停了

jButton2.setText(PAUSE);

jButton2.setEnabled(true);

}else if(action.equals(STOP)){

randomFetch.stop();

//jButton.setText(START);

jButton.setEnabled(false);

//将按钮变成灰色

//jButton2.setText(PAUSE);

jButton2.setEnabled(false);

//检查是否有两个Lable 内容相同

ArrayList list=new ArrayList<>();

for(Component comp:panel.getComponents()){

JLabel label=(JLabel)comp;

String text=label.getText();

boolean yesorno=list.contains(text);

if(!yesorno){

list.add(text);

}else{

System.out.println("wrong:"+text);

}

}

if (list.size()==LUCKYCOUNT) System.out.println("success");

}else if(action.equals(PAUSE)){

randomFetch.pause();

jButton2.setText(RESUME);

}else if(action.equals(RESUME)){

randomFetch.resume();

jButton2.setText(PAUSE);

}

}

public static void main(String args[]){

BlackBoard blackBoard=new BlackBoard();

blackBoard.setVisible(true);

//showComponents(blackBoard.getPanel());

}

}

本文的目的是线程的运用，所以屏幕部分写的比较简陋。其中要注意的是线程的暂停和恢复，需要同步的对象是线程本身，即synchronized (this){wait();}，否则会报异常：java.lang.IllegalMonitorStateException