1.第一关
（1）共享；小
（2）继承Thread类；实现Runnable接口
2.第二关
（1）新建状态
（2）就绪状态
（3）运行状态
（4）阻塞状态
（5）死亡状态
3.第三关
package step1;
class Thread1 extends Thread {
@Override
public void run() {//循环输出10次北京，每次显示后需休眠一段时间（1000毫秒以内）
/******** Begin ********/
for(int i = 0; i < 10; i++) {
("北京");
try {
sleep(1000);
}
catch(Exception e) {}
}
/******** End ********/
}
}
class Thread2 implements Runnable {
@Override
public void run() {//循环输出10次西安，每次显示后需休眠一段时间（1000毫秒以内）
/******** Begin ********/
for(int i = 0; i < 10; i++) {
("西安");
try {
(1000);
}
catch(Exception e) {}
}
/******** End ********/
}
}
public class Exe8_3 {
public static void main(String[] args) {
//创建 Thread1 对象 和 Thread2 对象并启动两个线程
/******** Begin ********/
Thread1 thread1 = new Thread1();
Thread2 thread2 = new Thread2();
();
new Thread(thread2).start();
/******** End ********/
}
}4.第四关
package step2;
// 协助三个线程之间通信的类
class SyncObject {
}
//线程A和B的类
class WaitThread extends Thread {
final SyncObject so;
String name;
WaitThread(SyncObject so, String name) {
= so;
= name;
}
@Override
public void run() {
synchronized(so) { //获得锁旗标
/******** Begin ********/
(name + " start");
try {
();
}
catch(Exception e) {
();
}
(); //唤醒其他线程
(name + " end");
/******** End ********/
}
}
}
//线程C的类
class NotifyThread extends Thread {
String name;
final SyncObject so;
NotifyThread(SyncObject so, String name) {
= so;
= name;
}
@Override
public void run() {
synchronized(so) {
/******** Begin ********/
try {
sleep(5000); //sleep后唤醒其他线程，然后自己wait
();
();
}
catch(Exception e) {
();
}
(name + " end");
/******** End ********/
}
}
}
//测试类，执行A，B，C三个线程
public class Exe8_4 {
public static void main(String[] args) {
SyncObject so = new SyncObject();
WaitThread thread1 = new WaitThread(so, "A");
WaitThread thread2 = new WaitThread(so, "B");
NotifyThread thread3 = new NotifyThread(so,"C");
/******** Begin ********/
();
();
();
/******** End ********/
}
}5.第五关
package step3;
//数据单元类，在其中实现写入和读出的同步
class DataUnit {
int number;
String name;
boolean available;
DataUnit() {
= 0;
= "";
= false;
}
public synchronized void write(int number, String name) {
/******** Begin ********/
if(available) { //如果有内容，则不能写，开始wait
try {
wait();
}
catch(Exception e) {
();
}
}
/******** End ********/
("Write " + number + "\t" + name);
= number;
= name;
available = true;
notify();
}
public synchronized void read() {
/******** Begin ********/
if(!available) { //如果没有内容，则不能读，开始wait
try {
wait();
}
catch(Exception e) {
();
}
}
/******** End ********/
("Read " + number + "\t" + name);
available = false;
notify();
}
}
class DataWriter extends Thread{
DataUnit du;
DataWriter(DataUnit du) {
= du;
}
@Override
public void run() {
/******** Begin ********/
for(int i = 0; i < 10; i++) { //写入10次
(i, "Name" + i);
}
/******** End ********/
}
}
class DataReader extends Thread {
DataUnit du;
DataReader(DataUnit du) {
= du;
}
@Override
public void run() {
/******** Begin ********/
for(int i = 0; i < 10; i++) { //读出10次
();
}
/******** End ********/
}
}
public class Exe8_5 {
public static void main(String[] args) {
/******** Begin ********/
DataUnit du = new DataUnit();
DataWriter dw = new DataWriter(du);
DataReader dr = new DataReader(du);
();
();
/******** End ********/
}
}6.第六关
package step4;
class CountThread extends Thread {
int num;
String name;
public CountThread(int num, String name) {
= num;
= name;
}
@Override
public void run() { // 在run方法中打印每次数数
/******** Begin ********/
for(int i = 0; i < num; i++) {
(name + ":" + i);
}
/******** End ********/
(name + " counts finish");
}
}
public class Exe8_6 {
public static void main(String[] args) {
CountThread ct1 = new CountThread(50000, "thread 1");
CountThread ct2 = new CountThread(50000, "thread 2");
/******** Begin ********/
(2); //设置第一个线程优先级为2
(8); //设置第二个线程优先级为8
(); //启动线程
();
/******** End ********/
}
}7.第七关
package step5;
import .*;
//两个线程共享
class SyncObject {
public int flag;//标记位，用于控制线程2是否sleep以及是否打印
}
class Thread1 extends Thread{
SyncObject so;
Thread1 (SyncObject so) {
= so;
}
@Override
public void run() {
//线程1打印2500次，此时线程2不sleep
/******** Begin ********/
Calendar start = ();
for(int i = 0; i < 1000; i++) {
("thread1:" + i);
}
Calendar end = ();
long time1 = () - ();
/******** End ********/
= 1;//设置flag为1，此后线程2将sleep
/******** Begin ********/
start = ();
for(int i = 0; i < 1000; i++) {
("thread1 again:" + i);
}
end = ();
long time2 = () - ();
/******** End ********/
("第一次打印，用时：" + time1);
("第二次打印，用时：" + time2);
= 2;//设置flag为2，此后线程2将不打印，便于查看结果
}
}
class Thread2 extends Thread {
SyncObject so;
Thread2(SyncObject so) {
= so;
}
@Override
public void run() {
/******** Begin ********/
for(int i = 0; i < 2000; i++) {
if( == 1) { //若flag为1， 则sleep
try {
sleep(1000);
}
catch(Exception e) {
();
}
}
else if( == 0)//若flag为0，则线程2将不打印，便于查看结果
("thraed2:" + i);
/******** End ********/
}
}
}
public class Exe8_7 {
public static void main(String[] args) {
SyncObject so = new SyncObject();
= 0;
Thread1 tr1 = new Thread1(so);
Thread2 tr2 = new Thread2(so);
/******** Begin ********/
(2);
(8);//设置线程2优先级高于线程1
();
();
/******** End ********/
}
}8.第八关
package step6;
class SonThread extends Thread {
int flag = 0;
@Override
public void run() {
/******** Begin ********/
for (int i = 0; i < 5000; i++) {
if (flag == 0) {
("i = " + i);
} else {
return;
}
}
/******** End ********/
}
}
public class Exe8_8 {
public static void main(String[] args) {
/******** Begin ********/
SonThread t = new SonThread();
();
for (int j = 0; j < 200; j++) {
("j = " + j);
}
();
= 1;
for (int j = 2000; j < 4000; j++) {
("j = " + j);
}
}
}9.第九关
package step7;
import .*;
class Goods {
Goods(String name, float price) {
= name;
= price;
}
String name;
float price;
}
class MyList {
MyList() {
goodsList = new ArrayList<Goods>();
}
ArrayList<Goods> goodsList;
//放一个
public synchronized void put(Goods g) {
/******** Begin ********/
(g);
notifyAll();
/******** End ********/
}
//放若干个
public synchronized void put(Goods[] g) {
/******** Begin ********/
((g));
notifyAll();
/******** End ********/
}
//取一个
public synchronized Goods get() {
/******** Begin ********/
while (() == 0) {
try {
wait();
} catch (Exception e) {
// ();
}
}
Goods g = (0);
return g;
/******** End ********/
}
//取若干个，个数为n
public synchronized Goods[] get(int n) {
/******** Begin ********/
while (() < n) {
try {
wait();
} catch (Exception e) {
// ();
}
}
Goods[] g = new Goods[n];
for (int i = 0; i < n; i++) {
g[i] = (0);
}
return g;
/******** End ********/
}
}
class MyThread1 extends Thread {
MyList goodsList;
MyThread1(MyList goodsList) {
= goodsList;
}
@Override
public void run() {
//循环10次，每次放一个
for (int i = 1; i <= 10; i++) {
(new Goods("thread1:" + i, (float) i / 10));
(i + ":Thread1 put");
}
}
}
class MyThread2 extends Thread {
MyList goodsList;
MyThread2(MyList goodsList) {
= goodsList;
}
@Override
public void run() {
//循环10次，每次取一个
for (int i = 1; i <= 10; i++) {
();
(i + ":Thread2 get");
}
}
}
class MyThread3 extends Thread {
MyList goodsList;
MyThread3(MyList goodsList) {
= goodsList;
}
@Override
public void run() {
//循环10次，每次放两个
for (int i = 1; i <= 10; i++) {
Goods[] goods = new Goods[2];
goods[0] = new Goods("thread3:" + i, (float) i / 20);
goods[1] = new Goods("thread3:" + i, (float) i / 50);
(goods);
(i + ":Thread3 put");
}
}
}
class MyThread4 extends Thread {
MyList goodsList;
MyThread4(MyList goodsList) {
= goodsList;
}
@Override
public void run() {
//循环10次，每次取两个
for (int i = 1; i <= 10; i++) {
(2);
(i + ":Thread4 get");
}
}
}
//测试类
public class Exe8_9 {
public static void main(String[] args) {
MyList goodsList = new MyList();
MyThread1 thread1 = new MyThread1(goodsList);
MyThread2 thread2 = new MyThread2(goodsList);
MyThread3 thread3 = new MyThread3(goodsList);
MyThread4 thread4 = new MyThread4(goodsList);
();
();
();
();
}
}10.第十关
package step8;
class MyThread extends Thread{
String name;
StringBuffer sendString;
StringBuffer recvString;
MyThread(String name, StringBuffer sendString, StringBuffer recvString) {
= name;
= sendString;
= recvString;
}
@Override
public void run() {
//循环100次，每次循环都sleep一段随机事件，然后收发消息
/******** Begin ********/
for(int i = 0; i < 100; i++) {
int time = (int)(() * 100);
try {
sleep(time);
}
catch(Exception e) {
();
}
sendMsg();
recvMsg();
/******** End ********/
}
}
//发送消息
public void sendMsg() {
synchronized(sendString) {
/******** Begin ********/
while(() > 0) {
try {
();
}
catch(Exception e) {
();
}
}
double content = ();
(name + content);
/******** End ********/
(name + " send " + content);
();
}
}
//接收消息
public void recvMsg() {
synchronized(recvString) {
/******** Begin ********/
while(() == 0) {
try {
();
}
catch(Exception e) {
();
}
}
/******** End ********/
(name + " recv " + recvString);
(0, ());
();
}
}
}
//测试类
public class Exe8_10 {
public static void main(String[] args) {
StringBuffer string1 = new StringBuffer();
StringBuffer string2 = new StringBuffer();
MyThread thread1 = new MyThread("A", string1, string2);
MyThread thread2 = new MyThread("B", string2, string1);
();
();
}
}