这里用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倍之差。
源码如下:
抽取号码部分:1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168package 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<T> {
//源数据池
private List<T> source;
//样本数
private int smaple;
//结果回调接口
private SampleShow<T> sampleShow;
//线程列表
private final List<Picker> threadList = new ArrayList<>();
//停止标识，使用volatile，是因为多线程共享同一变量时，需要变量改变时，线程能够即时发现
private volatile boolean stop = false;
//暂停标识
private volatile boolean suspend = false;
//暂停锁
private Object suspendLock=new Object();
public RandomFetch(List<T> source,int sample,SampleShow<T> 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);
}
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<T> {
public T show(int index, T data);
}
屏幕部分:1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122package 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<String> source=new ArrayList<>();
for(int i=0;i<100;i++){
source.add("seat"+i);
}
randomFetch = new RandomFetch<String>(source, LUCKYCOUNT, new SampleShow<String>() {
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);
}
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<String> 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