| test2.java | Ticket.java |
|
package com.java.homework2;
public class test2 {
/* 1.将之前的三个窗口修改为一个窗口买票。
2.新增加一个退票窗口。
3.将需求修改为当前所有速7的票都已经卖光了，如果窗口想卖票只有等待退票窗口有一张退票之后，售票窗口才可以买出。*/
public static void main(String[] args) {
Ticket ticket=new Ticket(10);
RefundTicket refundTicket=new RefundTicket(ticket);
SellTickets selltickets=new SellTickets(ticket);
Thread t1=new Thread(refundTicket);
Thread t2=new Thread(selltickets);
t2.start();
t1.start();
}
}
|
package com.java.homework2;
public class Ticket {
public int number;
public Ticket(int number){
this.number=number;
}
}
|
| SellTickets.java | RefundTicket.java |
|
package com.java.homework2;
public class SellTickets implements Runnable{
Ticket ticket;
public SellTickets(Ticket ticket){
this.ticket=ticket;
}
public void run() {
while(true){
try {
Thread.sleep(500); //都用Thread调用
//这些方法都是Object类里面的，Thread类继承了Object类
} catch (InterruptedException e1) {
e1.printStackTrace();
}
synchronized(ticket){
if(ticket.number<=0||ticket.number>10){
try {
ticket.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("卖出第 "+ticket.number+" 张票");
ticket.number--;
ticket.notify();
}
}
}
}
|
package com.java.homework2;
public class RefundTicket implements Runnable {
Ticket ticket;
public RefundTicket(Ticket ticket) {
this.ticket = ticket;
}
public void run() {
while (true) {
try {
Thread.sleep(1000); //都用Thread调用
} catch (InterruptedException e1) {
e1.printStackTrace();
}
synchronized (ticket) {
if (ticket.number ==10||ticket.number<0) {
try {
ticket.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
ticket.number++;
System.out.println("收到第 " + ticket.number + " 张退票");
ticket.notify();
}
}
}
}
|
| test3.java | Flag.java |
|
package com.java.homework3;
/*创建2个线程，每个线程都打印从0到99这100个数字，
* 线程之间不会出现交叉乱序打印，而是顺序地打印。*/
public class test3 {
public static void main(String[] args) {
Flag fl=new Flag();
print1 p1=new print1("No1.",fl);
print2 p2=new print2("No2.",fl);
Thread t1=new Thread(p1);
Thread t2=new Thread(p2);
t1.start();
t2.start();
}
}
|
package com.java.homework3;
public class Flag {
public boolean flag;
//控制交叉打印
public int num=0;
//控制打印的数
}
|
| print1.java | print2.java |
|
package com.java.homework3;
public class print1 implements Runnable {
String nameString = Thread.currentThread().getName();
Flag flag;
public print1(String nameString, Flag flag) {
this.nameString = nameString;
this.flag = flag;
}
public void run() {
while (true) {
synchronized (flag) {
if (flag.flag) {
try {
flag.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
if (flag.num <= 100) {
System.out.println(nameString + "这是第 " + flag.num + " 个数");
flag.num++;
}
flag.notify();
flag.flag = true;
}
}
}
}
|
package com.java.homework3;
public class print2 implements Runnable {
String nameString;
Flag flag;
public print2(String nameString, Flag flag) {
this.nameString = nameString;
this.flag = flag;
}
public void run() {
while (true) {
synchronized (flag) {
if (!flag.flag) {
try {
flag.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
if (flag.num <= 100) {
System.out.println(nameString + "这是第 " + flag.num + " 个数");
flag.num++;
}
flag.notify();
flag.flag = false;
}
}
}
}
|
| test4.java | Bullet.java |
|
package com.java.homework4;
/**
* 3、采用Java 多线程技术，设计实现一个符合生产者和消费者问题的程序。
* 对一个对象（枪膛）进行操作，其最大容量 是1颗子弹。
* 生产者线程是一个压入线程，它不断向枪膛中压入子弹；消费者线程是一个射出线程，它不断从枪膛中射出子弹。
* 要求： （1）给出分析过程说明。
* （提示：这是个生产者与消费者问题，也是线程的同步问题，
* 为了防止两个线程访问一个资源时出现忙等待，要使用的wait-notify函数，是两个线程交替执行; ）
* （2）程序输出，要模拟体现对枪膛的压入和射出操作；
* （3）设计程序时应考虑到两个线程的同步问题。
*/
public class test4 {
public static void main(String[] args) {
Bullet bullet=new Bullet();
AddBullet ab=new AddBullet(bullet);
ShootBullet sb=new ShootBullet(bullet);
Thread t1=new Thread(ab);
Thread t2=new Thread(sb);
t1.start();
t2.start();
}
}
|
package com.java.homework4;
public class Bullet {
public boolean flag;
//控制是否有子弹
}
|
| AddBullet.java | ShootBullet.java |
|
package com.java.homework4;
public class AddBullet implements Runnable{
public Bullet bullet;
public AddBullet(Bullet bullet){
this.bullet=bullet;
}
public void run() {
while(true){
synchronized(bullet){
if(bullet.flag){
try {
bullet.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("子弹上膛~~~~");
bullet.notify();
bullet.flag=true;
}
}
}
}
|
package com.java.homework4;
public class ShootBullet implements Runnable{
public Bullet bullet;
public ShootBullet(Bullet bullet){
this.bullet=bullet;
}
public void run() {
while(true){
synchronized(bullet){
if(!bullet.flag){
try {
bullet.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("射击！！！");
bullet.notify();
bullet.flag=false;
}
}
}
}
|
| test5.java |
|
|
/*手动新建一个计时器，并且自己创建一个任务。然后尝试使用如下定时器在固定的时间内去执行你想要到任务。
void schedule(TimerTask task, Date time)
安排在指定的时间执行指定的任务。
void schedule(TimerTask task, Date firstTime, long period)
安排指定的任务在指定的时间开始进行重复的固定延迟执行。
void schedule(TimerTask task, long delay)
安排在指定延迟后执行指定的任务。
void schedule(TimerTask task, long delay, long period)
安排指定的任务从指定的延迟后开始进行重复的固定延迟执行。
void scheduleAtFixedRate(TimerTask task, Date firstTime, long period)
安排指定的任务在指定的时间开始进行重复的固定速率执行。
void scheduleAtFixedRate(TimerTask task, long delay, long period)
安排指定的任务在指定的延迟后开始进行重复的固定速率执行。
*/
public class test5 {
public static void main(String[] args) {
Timer timer=new Timer();
Mytask mytask=new Mytask();
Date date=new Date();
GregorianCalendar c1=new GregorianCalendar(2017,2,18,14,60,40);
//月份默认从0开始
//GregorianCalendar 是 Calendar 的一个具体子类，提供了世界上大多数国家/地区使用的标准日历系统。
//GregorianCalendar(int year, int month, int dayOfMonth, int hourOfDay, int minute, int second) ;
date=c1.getTime();
//这个方法是夫类的，子类继承了夫类，所以也能调用
//Date getTime(); //返回一个表示此 Calendar 时间值（从历元至现在的毫秒偏移量）的 Date 对象
System.out.println(date);
timer.scheduleAtFixedRate(mytask, date, 3000);
}
}
class Mytask extends TimerTask{
public void run() {
System.out.println("Mytask.run()");
}
}
|
这个时间要设置成运行程序的时间往后，不然会执行好多次Mytask的任务；设置成运行程序时间之后，run方法会在到时间开始执行 |