有趣的题目，有趣的思想。

itpower

本帖最后由冯超于 2014-5-5 21:15 编辑

question1.

public class First {
public static void main(String[] args) {
// TODO Auto-generated method stub
try {
if() {
System.out.print("Hello ");
}else{
System.out.println("world!");
}
} catch (Exception e) {
e.printStackTrace();
}
}
}

复制代码

只能在if里面写代码，不能添加类，不能添加jar，不能更改所有内容，只能在if里面写代码输出 hello world!：
思路：匿名累不累，但是有什么类可以实例化了，匿名类部类一般都是实现的接口或者其他的，可以再里面写一个方法自己实现，object就是！
以下场景中常使用的匿名类部类：
js中：
$("#idName").click(function(e) {});
android中:
Button b = (Button)findViewById("buttonIdName");
b.setOnClickLinstener(new onClickLinsten(){ });
java中:

public class First {
public static void main(String[] args) {
// TODO Auto-generated method stub
try {
if(new Object() {
public boolean f() {
System.out.println("Hello");
return false;
}
}.f()) {
System.out.print("Hello ");
}else{
System.out.println("world!");
}
} catch (Exception e) {
e.printStackTrace();
}
}
}

复制代码

question2：如何让自己手机照的图片有倒影的效果呢？

import java.awt.AlphaComposite;
import java.awt.Color;
import java.awt.GradientPaint;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.RenderingHints;
import java.awt.image.BufferedImage;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.SwingUtilities;
@SuppressWarnings("serial")
public class Second extends JPanel {
private BufferedImage img;
public Second() {
img = ImageUtil.loadImage("D://gril2.jpg"); // 源图像文件名
setBackground(Color.BLACK);
}
@Override
protected void paintComponent(Graphics g) {
super.paintComponent(g);
Graphics2D g2d = (Graphics2D) g.create();
g2d.setRenderingHint(RenderingHints.KEY_INTERPOLATION,
RenderingHints.VALUE_INTERPOLATION_BICUBIC);
g2d.translate(30, 30);
int w = img.getWidth();
int h = img.getHeight();
// 绘制原图像
g2d.drawImage(img, 0, 0, null);
// 绘制反射的图像
g2d.translate(0, h);
g2d.drawImage(img, 0, 0, w, (int) (h / 1.5), 0, h, w, 0, null);
// 绘制透明的渐变
g2d.setPaint(new GradientPaint(0, 0, new Color(1.0f, 1.0f, 1.0f, 0.2f), 0, h / 2,
new Color(1.0f, 1.0f, 1.0f, 1.0f)));
g2d.setComposite(AlphaComposite.DstOut); // 关键就在DstOut
g2d.fillRect(0, 0, w, h);
g2d.dispose();
}
private static void createGuiAndShow() {
JFrame frame = new JFrame("Reflected Image");
frame.getContentPane().add(new Second());
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setSize(450, 620);
frame.setLocationRelativeTo(null);
frame.setAlwaysOnTop(true);
frame.setVisible(true);
}
public static void main(String[] args) {
SwingUtilities.invokeLater(new Runnable() {
@Override
public void run() {
createGuiAndShow();
}
});
}
}

复制代码

import java.awt.image.BufferedImage;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import javax.imageio.ImageIO;
public class ImageUtil {
public static BufferedImage loadImage(String imgPath) {
// TODO Auto-generated method stub
BufferedImage image = null;
try {
image = ImageIO.read(new FileInputStream(imgPath));
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return image;
}
}

复制代码

上照片：

冯超 · 冯超

项目：秒表项目
在具体使用时，如果想计时开始，则按住鼠标，如果想停止计时，则松开鼠标，按住鼠标则计时重新开始，周而复始。

watch类：

package com.feng.watchtool;
import java.awt.AWTEvent;
import java.awt.Canvas;
import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.event.MouseEvent;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class StopWatch extends Canvas implements Runnable {
/**
*
*/
private Long start; //开始时间
private Long end; //结束时间
Thread thread_time; //开始于结束的线程
boolean flag = true;
private static final long serialVersionUID = 1L;
/**
* @wbp.parser.entryPoint
*/
public StopWatch() {
//this.setBackground(Color.blue);
enableEvents(AWTEvent.MOUSE_EVENT_MASK); //注册鼠标事件
setBackground(Color.WHITE);
start = end = System.currentTimeMillis();
}
/**
* 重新写paint方法初始化布局
* @wbp.parser.entryPoint
*/
public void paint(Graphics g) {
// TODO Auto-generated method stub
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("mm:ss:SS");
Date time = null;
try {
//
time = simpleDateFormat.parse("00:00:00");
} catch (ParseException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
// time.setTime(time.getTime());
time.setTime(end - start + time.getTime()); //计时
String watchTime = simpleDateFormat.format(time);
//System.out.println(watchTime);
//化秒表的界面
g.drawRect(0, 0, 280, 160); //画一个矩形
g.fill3DRect(0, 0, 280, 160, true); //为矩形填充颜色
g.setColor(Color.WHITE); //为字体设置颜色
Font font = new Font("Default", Font.PLAIN, 50); //设置字体的风格
g.setFont(font);
g.drawString(watchTime, 20, 100);
}
//重写鼠标事件了解事件机制原理
protected void processMouseEvent(MouseEvent e) {
// TODO Auto-generated method stub
//鼠标按下
if(e.getID() == MouseEvent.MOUSE_PRESSED) {
start = end = System.currentTimeMillis();
//重新绘制图
repaint();
flag = true;
new Thread(this).start(); //启动当前线程
}
//鼠标释放
if(e.getID() == MouseEvent.MOUSE_RELEASED) {
flag = false; //结束线程
System.out.println(end - start);
}
}
/**
*
*/
public void run() {
// TODO Auto-generated method stub
while(flag) {
end = System.currentTimeMillis();
repaint();
}
}
}

复制代码

工具类：

package com.feng;
import java.awt.Dimension;
import java.awt.Toolkit;
import javax.swing.JFrame;
import javax.swing.SwingUtilities;
public class SwingConsole {
public static void run(final JFrame frame, final String title, final int width, final int height) {
//一个子线程
SwingUtilities.invokeLater(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.pack();
frame.setTitle(title);
frame.setSize(width, height);
//显示并且居中
frame.setLocationRelativeTo(null);
frame.setVisible(true);
}
});
};
}

复制代码

测试类：

package com.feng.watchtool;
import java.awt.BorderLayout;
import java.awt.Button;
import java.awt.Label;
import java.util.Date;
import javax.swing.JFrame;
import com.feng.SwingConsole;
/**
* 项目需求：秒表项目模拟现实生活中的秒表
*
* 要求：在具体使用时，如果想计时开始，则按住鼠标，如果想停止计时，则松开鼠标。
* @author fengchao
*
*/
public class Watch {
public static void main(String[] args) {
// TODO Auto-generated method stub
JFrame frame = new JFrame();
StopWatch stopWatch = new StopWatch();
Label b1 = new Label(" 鼠标按下开始计数");
Label b2 = new Label(" 鼠标松下计数停止");
Label b3 = new Label("边界");
Label b4 = new Label("边界");
frame.add(b1, BorderLayout.NORTH);
frame.add(b2, BorderLayout.SOUTH);
frame.add(b3, BorderLayout.WEST);
frame.add(b4, BorderLayout.EAST);
frame.add(stopWatch, BorderLayout.CENTER);
SwingConsole.run(frame, "秒表", 360, 240);
/* Date date = new Date();
System.out.println(date.getTime());
System.out.println(System.currentTimeMillis());*/
}
}

复制代码

事件机制的原理：注册 ----》使用

冯超 · 冯超

java中的关机工具原理：
图片如下：
主类：

package com.feng.shutdown;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Timer;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
public class CloseComputer extends JFrame implements ActionListener {
private static final long serialVersionUID = 1L;
private String key;
private JLabel showTime; //显示倒计时
private Timer timer; //延时时间
private boolean time_show = true; //线程显示时间标示
private JButton btn_3;
public CloseComputer() {
getContentPane().setLayout(null);
JLabel label = new JLabel("请选择关机的方式");
label.setBounds(34, 9, 128, 15);
getContentPane().add(label);
JButton btn_1 = new JButton("倒计时关机");
btn_1.setBounds(10, 112, 120, 23);
btn_1.addActionListener(this);
getContentPane().add(btn_1);
JButton btn_2 = new JButton("定时关机");
btn_2.setBounds(180, 112, 96, 23);
btn_2.addActionListener(this);
getContentPane().add(btn_2);
btn_3 = new JButton("取消关机");
btn_3.setEnabled(false);
btn_3.setBounds(328, 112, 96, 23);
btn_3.addActionListener(this);
getContentPane().add(btn_3);
showTime = new JLabel("");
showTime.setBounds(130, 65, 158, 15);
getContentPane().add(showTime);
}
//点击事件
@Override
public void actionPerformed(ActionEvent e) {
// TODO Auto-generated method stub
String ActionCommand = e.getActionCommand(); //获取按钮的名称
btn_3.setEnabled(true);
if(e.getSource() instanceof JButton) {
if("倒计时关机".equals(ActionCommand)) {
timer = new Timer();//类初始化的时候就实例化
time_show = true;
cutDown();
}
if("定时关机".equals(ActionCommand)) {
timer = new Timer();//类初始化的时候就实例化
timing();
}
if("取消关机".equals(ActionCommand)) {
System.out.println("取消关机");
btn_3.setEnabled(false);
timer.cancel(); //取消
time_show = false;
//System.out.println(Thread.currentThread().getName());
}
}
}
private void cutDown() {
// TODO Auto-generated method stub
key = JOptionPane.showInputDialog(this, "请输入倒计时关机的时间(m)", "输入框", 1);
boolean b = (key != null && isNum(key));
if(b) {
final Long second = Long.valueOf(key);
//如何动态的改变JLabel上面的内容线程
new Thread(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
Long i = second;
while(i > 0 && time_show) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
showTime.setText("倒计时" + i + "s关机");
i--;
//System.out.println(i);
}
}
}).start();;
CountTimeTool.delayTime(second, timer);
} else {
JOptionPane.showMessageDialog(null,"必须输入整形数字");
}
}
/**
* 定时工具
*/
public void timing() {
key = JOptionPane.showInputDialog("请输入关机时间(格式xx:xx):");
boolean b = (key != null && vaildate(key));
if(!b) {
JOptionPane.showMessageDialog(this,
"定时时间不对", "系统信息", JOptionPane.ERROR_MESSAGE);
return;
}
String time = getSystemTime();
long second = getSecond(time, key);
if(second <= 0) {
JOptionPane.showMessageDialog(this,
"定时时间不对", "系统信息", JOptionPane.ERROR_MESSAGE);
return;
}
showTime.setText("关机时间:" + key);
System.out.println(second);
CountTimeTool.delayTime(second, timer);
//System.out.println(second);
}
public boolean isNum(String str) {
return str.matches("[0-9]+");
}
public static void main(String[] args) {
SwingConsole.run(new CloseComputer(), "关机工具", 446, 450);
}
/**
*
* @param date
* @return
*/
public boolean vaildate(String date) {
boolean b = false;
String reg = "[0-9]{2}:[0-9]{2}";
Pattern p = Pattern.compile(reg);
Matcher m = p.matcher(date);
b = m.matches();
return b;
}
/**
* 获取系统当前时间
* @return
*/
public String getSystemTime() {
String time = "";
Date date = new Date();
// System.out.println(date);
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("HH:mm");
time = simpleDateFormat.format(date);
//System.out.println(time);
return time;
}
/**
* 获取两个时间差以m为单位
* @param time1 系统时间
* @param tim2 输入的时间
* @return
*/
public long getSecond(String time1, String time2) {
long second = 0l;
String[] time1_s = time1.split(":");
String[] time2_s = time2.split(":");
long hourse = Long.valueOf(time2_s[0]) - Long.valueOf(time1_s[0]);
long minute = Long.valueOf(time2_s[1]) - Long.valueOf(time1_s[1]);
if(hourse < 0) {
return 0;
}
second = hourse * 3600 + (minute>0?minute*60:0);
//System.out.println(hourse + ":::" + minute);
return second;
}
}

复制代码

延时和关机类：

package com.feng.shutdown;
import java.util.Timer;
import java.util.TimerTask;
public class CountTimeTool {
public static void delayTime(Long second,Timer timer) {
// TODO Auto-generated method stub
Long delay = 1000l;
CutDownTool cut = new CutDownTool();
//第一个参数为执行函数
timer.schedule(cut, second*delay);
}
}

复制代码

package com.feng.shutdown;
import java.io.IOException;
import java.util.TimerTask;
public class CutDownTool extends TimerTask {
@Override
public void run() {
// TODO Auto-generated method stub
//System.out.println("执行了关机············");
try {
Runtime.getRuntime().exec("shutdown -s"); //关机程序
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}

复制代码

swing工具类：

package com.feng.shutdown;
import javax.swing.JFrame;
import javax.swing.SwingUtilities;
public class SwingConsole {
public static void run(final JFrame frame, final String title, final int width, final int height) {
//一个子线程
SwingUtilities.invokeLater(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.pack();
frame.setTitle(title);
frame.setSize(width, height);
//显示
frame.setVisible(true);
}
});
};
}

复制代码

我把swing程序到出，用bat批处理过，所以安装了jdk jre环境的电脑可以直接双击bat文件可以打开。

代码哪里不懂可以问群主····

下章：秒表（事件加线程）

冯超 · 冯超

question6:
场景：火车站售票系统
* 描述：火车站售票系统用来描述一个售票的过程，如今科技这么复杂，买票的方式
* 也多种多样，而火车站售票系统就是实现多个人并发购买票的一个过程！

这个也就是设计多个线程共抢能一个资源的过程，同步synch真的是一个很好的解决方法。
tickets:

package com.feng;
public class Tickets implements Runnable {
private int ticketNumbers; //该系统共有的票数
public Tickets(int ticketNumbers) {
this.ticketNumbers = ticketNumbers;
}
/**
* 出售票的一个过程
*/
public void saleTicket() {
while(true) {
synchronized (this) {
if(ticketNumbers > 0) {
System.out.println("顾客来到了--->" +
Thread.currentThread().getName()+ "站台");
System.out.println("顾客开始买票");
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("顾客买到了票");
ticketNumbers--;
System.out.println("顾客离开了--->" + Thread.currentThread().getName() + "站台");
System.out.println("总票数为：" + ticketNumbers);
}
if(ticketNumbers == 0 ) {
System.out.println("对不起票已经卖完········");
break;
}
}
}
}
//
@Override
public void run() {
// TODO Auto-generated method stub
saleTicket();
}
}

复制代码

测试：

package com.feng;
/**
*
* @author Administrator
* 场景：火车站售票系统
* 描述：火车站售票系统用来描述一个售票的过程，如今科技这么复杂，买票的方式
* 也多种多样，而火车站售票系统就是实现多个人并发购买票的一个过程！
*
*/
public class Station {
public static void main(String[] args) {
// TODO Auto-generated method stub
Tickets ticket = new Tickets(10);
Thread th1 = new Thread(ticket);
th1.setName("站台1");
Thread th2 = new Thread(ticket);
th2.setName("站台2");
Thread th3 = new Thread(ticket);
th3.setName("站台3");
th1.start();
th2.start();
th3.start();
}
}

复制代码

结果：
顾客来到了--->站台1站台
顾客开始买票
顾客买到了票
顾客离开了--->站台1站台
总票数为：9
顾客来到了--->站台2站台
顾客开始买票
顾客买到了票
顾客离开了--->站台2站台
总票数为：8
顾客来到了--->站台2站台
顾客开始买票
顾客买到了票
顾客离开了--->站台2站台
总票数为：7
顾客来到了--->站台3站台
顾客开始买票
顾客买到了票
顾客离开了--->站台3站台
总票数为：6
顾客来到了--->站台2站台
顾客开始买票
顾客买到了票
顾客离开了--->站台2站台
总票数为：5
顾客来到了--->站台2站台
顾客开始买票
顾客买到了票
顾客离开了--->站台2站台
总票数为：4
顾客来到了--->站台1站台
顾客开始买票
顾客买到了票
顾客离开了--->站台1站台
总票数为：3
顾客来到了--->站台2站台
顾客开始买票
顾客买到了票
顾客离开了--->站台2站台
总票数为：2
顾客来到了--->站台2站台
顾客开始买票
顾客买到了票
顾客离开了--->站台2站台
总票数为：1
顾客来到了--->站台2站台
顾客开始买票
顾客买到了票
顾客离开了--->站台2站台
总票数为：0
对不起票已经卖完········
对不起票已经卖完········
对不起票已经卖完········

下章：java中的关机工具原理，敬请期待

冯超 · 冯超

ς高眼光の目标发表于 2014-5-9 05:38
lz 如果有技术分奖励或者会带动更多人猜你这些代码

思想很重要
自学java 到ssh 从js 到easyui，有的时候代码是敲出来了，但是不知道为什么这么敲。这当做我修炼的一个回忆罢了！

ς高眼光の目标 · ς高眼光の目标

lz 如果有技术分奖励或者会带动更多人猜你这些代码

曹冬明 · 曹冬明

你明儿累不累，哈哈，玩笑了！

itpower · itpower

有妹纸,{:3_51:},求介绍

姜蕾蕾 · 姜蕾蕾

楼主威武……

fendoubuxi · fendoubuxi

楼主对多线程很有研究呀~

冯超 · 冯超

question5：
场景如下：
   妈妈在下午5点开始到厨房做晚餐，可是在准备做饭的材料时发现
   酱油用完了，因此叫儿子去买。
   妈妈在儿子把酱油买回来之前没什么能干的只好等待。
   直到儿子把酱油买回来，妈妈才开始煮饭，最后终于把饭煮好。

面向对象的思想：
妈妈一个实体
儿子一个实体
他们各自都是互不干涉线程。

当妈妈正在做饭的过程中，突然让儿子去买酱油，如何让儿子做完事后，妈妈继续完成他的任务呢？
方法是join：
join的理解：
   * 当一个子线程中含有其他子线程的时候，若thread.join
   * 则合并了2个线程，必须按队列输出!

妈妈类：

package com.feng;
public class Mother implements Runnable {
/**
* join的理解：
* 当一个子线程中含有其他子线程的时候，若thread.join
* 则合并了2个线程，必须按队列输出!
*/
public void cooking() {
System.out.println("妈妈正在做饭。。。");
System.out.println("妈妈发现没酱油了。。。");
System.out.println("妈妈叫儿子去买啊酱油");
Son son = new Son();
son.start();
try {
son.join();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("妈妈继续做饭");
System.out.println("妈妈终于把饭做好了!!");
}
@Override
public void run() {
// TODO Auto-generated method stub
cooking();
}
}

复制代码

儿子类：

package com.feng;
public class Son extends Thread {
@Override
public void run() {
// TODO Auto-generated method stub
super.run();
buySomething();
}
//儿子买酱油的过程
private void buySomething() {
// TODO Auto-generated method stub
System.out.println("儿子跑到了商店");
System.out.println("儿子买到了酱油");
try {
Thread.sleep(5000); //延时5s
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("儿子把酱油交给了妈妈。。。。");
}
}

复制代码

测试类：

package com.feng;
/**
*
* @author Administrator
* 妈妈在下午5点开始到厨房做晚餐，可是在准备做饭的材料时发现
* 酱油用完了，因此叫儿子去买。
* 妈妈在儿子把酱油买回来之前没什么能干的只好等待。
* 直到儿子把酱油买回来，妈妈才开始煮饭，最后终于把饭煮好。
*/
public class Cooking {
//做饭场景
public static void main(String[] args) {
// TODO Auto-generated method stub
Thread mother = new Thread(new Mother());
mother.start();
}
}

复制代码

结果：
妈妈正在做饭。。。
妈妈发现没酱油了。。。
妈妈叫儿子去买啊酱油
儿子跑到了商店
儿子买到了酱油
儿子把酱油交给了妈妈。。。。
妈妈继续做饭
妈妈终于把饭做好了!!

重点：对于join的理解！

Conning · Conning

看见有妹子我就进来了- -

冯超 · 冯超

question5:
a,b,c去水房接水，他们在水龙头是排队接水的，谁先到达水龙头，谁先接到水
但是他们都接到水后不先喝，等其他人都接到水后再一起喝水。

persion类：

package com.feng;
public class Persion extends Thread {
private String stuName;
private Water water;
public String getStuName() {
return stuName;
}
public void setWater(Water water) {
this.water = water;
}
public Persion(String stuName) {
this.stuName = stuName;
}
/**
* 人接水的一个过程
*/
public void receivedWater() {
System.out.println(stuName + "--->来到水房<-----");
water.folwerWater(this);
System.out.println(stuName + "--->正在喝水<-----");
}
/**
* 子线程运行
*/
public void run() {
// TODO Auto-generated method stub
super.run();
receivedWater();
}
}

复制代码

water类：

package com.feng;
public class Water {
private int numbers;
private int i = 0;
public Water(int numbers) {
this.numbers = numbers;
}
/**
* 水龙头流水的方法
* wait()与notifyAll()的理解：
* 一般在同步代码块使用
* wait 使该子线程等待，直到被唤醒，该子线程才往下执行，否则则一直阻塞
* notifyAll 唤醒所有在该线程中等待的线程 ,唤醒需要条件
* @param p
*/
public synchronized void folwerWater(Persion p) {
//定义同步代码块
synchronized (this) {
System.out.println(p.getStuName() + "--->正在接水");
try {
Thread.sleep(3000); //延时3m
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(p.getStuName() + "--->接水结束");
if(i < numbers-1) {
i++;
try {
wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
} else {
notifyAll();
}
}
}
}

复制代码

测试类：

package com.feng;
/**
* a,b,c去水房接水，他们在水龙头是排队接水的，谁先到达水龙头，谁先接到水
* 但是他们都接到水后不先和，等其他人都接到水后再一起喝水。
* @author Administrator
*
*/
public class Test {
public static void main(String[] args) {
// TODO Auto-generated method stub
Persion a = new Persion("A");
Water water = new Water(3);
a.setWater(water);
Persion b = new Persion("B");
b.setWater(water);
Persion c = new Persion("C");
c.setWater(water);
a.start();
b.start();
c.start();
}
}

复制代码

结果如下：
A--->来到水房<-----
A--->正在接水
C--->来到水房<-----
B--->来到水房<-----
A--->接水结束
B--->正在接水
B--->接水结束
C--->正在接水
C--->接水结束
B--->正在喝水<-----
C--->正在喝水<-----
A--->正在喝水<-----

重点在与wait和notifyAll的理解！！！

冯超 · 冯超

本帖最后由冯超于 2014-5-8 11:37 编辑

quest4:
四个学生,下课后往水房接水,由于水龙头只有一个,而且是排队接水,所以谁先到达水房,谁就能先喝水.

package com.feng.thread;
/**
* 单利模式设计
* @author Administrator
*
*/
public class Water {
private static Water water;
private Water() {};
/**
* 水龙头流水的过程
* synchronized的理解:
* 同步:当多个线程访问同一个同步代码块或者同步函数时候,哪个线程先进入这个同步代码快
* 或者同步函数,其他线程就必须等待,直到执行完为止!
* @param p
*/
public synchronized void flowerWater(Persion p) {
System.out.println("水龙头正在为---->" + p.getStuName() + "流水");
try {
Thread.sleep(3000); //延时3 s
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("水龙头结束为---->" + p.getStuName() + "流水");
}
public static Water getInstence() {
if(water == null) {
water = new Water();
}
return water;
}
}
<DIV class=blockcode>
<BLOCKQUOTE>package com.feng.thread;
public class Persion extends Thread {
private String stuName;
private Water water;
public String getStuName() {
return stuName;
}
public void setWater(Water water) {
this.water = water;
}
public Persion(String stuName) {
this.stuName = stuName;
}
/**
* 接水的过程
*/
public void receiveWater() {
System.out.println(stuName + "来到水房");
water.flowerWater(this);
System.out.println(stuName + "正在喝水");
}
//子线程执行的方法
@Override
public void run() {
// TODO Auto-generated method stub
super.run();
receiveWater();
}
}

复制代码

测试类:

package com.feng.thread;
/**
* 四个学生,下课后往水房接水,由于水龙头只有一个,而且是排队接水,所以谁先到达水龙头,谁就能先喝水.
* @author Administrator
*
*/
public class Test {
public static void main(String[] args) {
// TODO Auto-generated method stub
Persion a = new Persion("A");
a.setWater(Water.getInstence());
Persion b = new Persion("B");
b.setWater(Water.getInstence());
Persion c = new Persion("C");
c.setWater(Water.getInstence());
a.start();
b.start();
c.start();
}
}

复制代码

结果如下:
A来到水房
B来到水房
水龙头正在为---->A流水
C来到水房
水龙头结束为---->A流水
A正在喝水
水龙头正在为---->C流水
水龙头结束为---->C流水
C正在喝水
水龙头正在为---->B流水
水龙头结束为---->B流水
B正在喝水

复制代码

唯一的就是增加了同步代码块的理解:
synchronized
指在多线程中,当多个子线程访问一个同步代码块或者同步函数的时候,哪个子线程先进入,其他子线程就必须等待,直到该同步代码块空闲,其他线程才能在进去.

冯超 · 冯超

本帖最后由冯超于 2014-5-8 10:17 编辑

quest3：
四个学生
   A，B，C，D下课后往水房跑，在具体接水过程中
   由于水房只有一个水龙头，所以四个学生通过抢夺形式接水，因此谁先接完水不确定。

以面向对象的思想分析：
   学生水龙头
过程：
学生 ----》水房
水房中的水龙头 -----》流水

学生类：

package com.feng.water;
public class Person extends Thread{
private String stuName;
private Water water;
public Person(String stuName) {
this.stuName = stuName;
}
public String getStuName() {
return stuName;
}
public void setStuName(String stuName) {
this.stuName = stuName;
}
public Water getWater() {
return water;
}
public void setWater(Water water) {
this.water = water;
}
/**
* 人喝水的动作
*/
public void receiveWater() {
System.out.println(stuName + "---->跑向饮水机");
water.flowWater(this);
System.out.println(stuName + "------->正在喝水");
}
public void run() {
// TODO Auto-generated method stub
receiveWater();
}
}

复制代码

水龙头：

package com.feng.water;
/**
* 饮水机
* @author fengchao
*
*/
class Water extends Thread {
/**
* 饮水机所具备的方法：流水
*/
private static Water water;
private Water(){};
public void flowWater(Person p) {
System.out.println(p.getStuName() + "来到了饮水机。。。。。");
try {
Thread.sleep(3000); //休眠3m
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(p.getStuName()+ "已经正在接水。。。。。");
}
public static Water getInstence() {
if(water == null) {
water = new Water();
}
return water;
}
}

复制代码

如何流水的方法没实现，用syso 代替！

测试类：

package com.feng.water;
/**
* 四个学生
* A，B，C，D下课后往水房跑，在具体接水过程中
* 由于水房只有一个水龙头，所以四个学生通过抢夺形式接水，因此谁先接完水不确定
* @author fengchao
*
*/
public class First {
public static void main(String args[]) {
Person a = new Person("A");
//a.setName("A");
a.setWater(Water.getInstence());
Person b = new Person("B");
//b.setName("B");
b.setWater(Water.getInstence());
Person c = new Person("C");
//c.setName("C");
c.setWater(Water.getInstence());
a.start();
b.start();
c.start();
//System.out.println(Water.getInstence() instanceof Water);
}
}

复制代码

结果：
B---->跑向饮水机
B来到了饮水机。。。。。
A---->跑向饮水机
A来到了饮水机。。。。。
C---->跑向饮水机
C来到了饮水机。。。。。
B已经正在接水。。。。。
B------->正在喝水
A已经正在接水。。。。。
C已经正在接水。。。。。
C------->正在喝水
A------->正在喝水

这个并是：多线程并发的一个过程。简称不排队接水的一个过程，谁先到达，与谁先接到水无必然关系，因为是不排队。

下章：排队接水接完水一起喝水。敬请期待！

菠萝包丶 · 菠萝包丶

哈哈哈，有妹子，为了妹子顶一个;P

神马 · 神马

呵呵，有意思，支持一下

帐号		自动登录	找回密码
密码			加入黑马

有趣的题目，有趣的思想。

评分

16 个回复

黑马骑士勋章