sleepjava的简单介绍

本文目录一览：

• 1、java中的sleep和wait的区别
• 2、java 中sleep()方法或者wait()方法的使用
• 3、java sleep()
• 4、java中的sleep是什么意思
• 5、java sleep(1000)和wait(1000)有区别吗？
• 6、java sleep方法

java中的sleep和wait的区别

sleep和wait的区别：

1、sleep的意思是：睡，睡觉，睡眠。

2、wait的意思是：等候，推迟，延缓等待，耽搁，伺候用餐。

拓展资料

sleep的用法

1、They were exhausted from lack of sleep

由于缺乏睡眠，他们非常疲惫。

2、During the car journey, the baby slept

坐车来的路上，宝宝睡着了。

3、I think he may be ready for a sleep soon.

我想他也许很快就要睡一觉了。

4、I can’t get to sleep with all that singing.

那些歌声搅得我无法入睡。

5、I didn’t lose too much sleep over that investigation.

我并不太担心那个调查。

wait

1、I walk to a street corner and wait for the school bus

我走到街角等校车。

2、There’ll be a car waiting for you

会有辆汽车等你。

3、I want to talk to you, but it can wait

我想和你谈谈，但可以晚点再说。

4、If you think this all sounds very exciting, just wait until you read the book

如果你觉得所有这些听起来令人兴奋，那就等着去读这本书吧。

5、’Wait a minute!’ he broke in. ‘This is not giving her a fair hearing!’

“等一下，”他插嘴说，“这没有给她一个公平的解释机会！”

java 中sleep()方法或者wait()方法的使用

简单说：sleep由线程自动唤醒，wait必须显示用代码唤醒。

sleep是Thread类的静态方法。sleep的作用是让线程休眠制定的时间，在时间到达时恢复，也就是说sleep将在接到时间到达事件事恢复线程执行，例如：

try{

System.out.println(“I’m going to bed”);

Thread.sleep(1000);

System.out.println(“I wake up”);

}

catch(IntrruptedException e) {

}

wait是Object的方法，也就是说可以对任意一个对象调用wait方法，调用wait方法将会将调用者的线程挂起，直到其他线程调用同一个对象的notify方法才会重新激活调用者，例如：

//Thread 1

try{

obj.wait();//suspend thread until obj.notify() is called

}

catch(InterrputedException e) {

}

java sleep()

下面分别是服务器端和客户端的代码，先运行服务器端，再运行客户端

服务器端：

import java.awt.event.*;

import java.io.*;

import java.net.*;

import java.util.*;

import java.util.List;

import javax.swing.*;

public class ChatServer {

public static void main(String[] args) throws Exception {

ServerSocket ss = new ServerSocket(9000);

ServerFrame sf = new ServerFrame();

sf.launchFrame();

List list = new ArrayList(); // 创建数组

while (true) { // 开启多线程

Socket s = ss.accept();

list.add(s);

Thread t = new ServerThread(s, list, sf);

t.start();

}

}

}

class ServerThread extends Thread { // 创建线程类

Socket s;

BufferedReader in;

PrintWriter out;

ServerFrame sf;

public ServerThread(Socket s, List list, ServerFrame sf) {

this.s = s;

this.sf = sf;

sf.sokectList = list;

try {

in = new BufferedReader(new InputStreamReader(s.getInputStream()));

out = new PrintWriter(s.getOutputStream());

} catch (IOException e) {

e.printStackTrace();

}

}

public void run() {

while (true) {

try {

String str = in.readLine();

if (str == null)

continue;

sf.jta.append(“接收到：” + str + “\n”);

} catch (IOException e) {

return;

}

}

}

}

class ServerFrame {

List sokectList;

JTextField jtf;

JTextArea jta;

PrintWriter out;

public void launchFrame() {

JFrame frame = new JFrame(“服务器端”); // 创建 frame对象

frame.setSize(400, 300); // 设置fram大小

frame.setLocation(300, 250);

jta = new JTextArea();

jta.setEditable(false);

jtf = new JTextField();

jtf.addActionListener(new ActionListener() { // 注册监听器

public void actionPerformed(ActionEvent arg0) {

send();

}

});

frame.getContentPane().add(new JScrollPane(jta));

frame.getContentPane().add(jtf, “South”);

frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

frame.setVisible(true);

}

public void send() { // 输出文字

String text = this.jtf.getText();

this.jtf.setText(“”);

if(sokectList==null) {

jta.append(“无客户端，发送失败：” + text + “\n”);

return;

}

jta.append(“发送指令：” + text + “\n”);

Iterator it = sokectList.iterator();

while (it.hasNext()) {

Socket socket = (Socket) (it.next());

try {

out = new PrintWriter(socket.getOutputStream());

} catch (IOException e) {

// TODO Auto-generated catch block

jta.append(“与客户端连接失败！\n”);

continue;

}

out.println(text);

out.flush();

}

}

}

客户端：

import java.awt.BorderLayout;

import java.awt.Frame;

import java.awt.Panel;

import java.awt.TextArea;

import java.awt.event.*;

import java.io.*;

import java.net.*;

import javax.swing.*;

public class ChatClient {

public static void main(String[] args) {

ChatClient cc = new ChatClient();

while(true)

cc.receive();

}

static boolean boo;

Frame clientFrame;

Panel topPanel;

TextArea topTextArea;

Socket s;

BufferedReader in;

PrintWriter out;

public ChatClient() {

this.clientFrame = new Frame(“客户端”);

this.clientFrame.setBounds(350, 250, 150, 250);

this.clientFrame.setResizable(false);

this.clientFrame.setVisible(true);

this.topPanel = new Panel();

this.clientFrame.setBounds(350, 250, 150, 200);

this.topTextArea = new TextArea();

this.topPanel.add(this.topTextArea);

this.clientFrame.add(this.topPanel, BorderLayout.NORTH);

this.clientFrame.pack();

this.clientFrame.addWindowListener(new WindowAdapter() {

public void windowClosing(WindowEvent e) {

int var = JOptionPane.showConfirmDialog(null, “退出？”,

“退出”, JOptionPane.OK_CANCEL_OPTION);

if (var == JOptionPane.OK_OPTION)

System.exit(0);

}

});

try {

s = new Socket(“127.0.0.1”, 9000);//设置端口

in = new BufferedReader(new InputStreamReader(s.getInputStream()));//创建对象in

out = new PrintWriter(new OutputStreamWriter(s.getOutputStream()));//创建对象out

} catch(UnknownHostException e) {//捕捉异常

e.printStackTrace();

} catch(ConnectException e) {

JOptionPane.showMessageDialog(null, “与服务器连接失败，请确认服务器是否已经开启！”);

System.exit(-1);

} catch(IOException e) {

e.printStackTrace();

}

}

public void receive() { // 读信息

try {

String text = in.readLine();

if(“STOP”.equals(text.toUpperCase())) {

if(boo) {

this.topTextArea.append(“结束发送！\n”);

boo = false;

}

return;

}

if(“START”.equals(text.toUpperCase())) {

boo = true;

this.topTextArea.append(“开始向服务器发送数据：\n”);

new SendThread(this).start();

return;

}

this.topTextArea.append(“接收到无效指令：” + text + “\n”);

} catch (SocketException e) {

JOptionPane.showMessageDialog(null, “与服务器断开连接！”);

System.exit(-1);

} catch (IOException e) {

e.printStackTrace();

return;

}

}

public void send() {

while(boo) {

String str = Math.random() + “”;

out.println(str);

out.flush();

this.topTextArea.append(“发送：” + str + “\n”);

try {

Thread.sleep(1000);

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

}

}

}

class SendThread extends Thread {

ChatClient cc;

SendThread(ChatClient cc) {

this.cc = cc;

}

@Override

public void run() {

// TODO Auto-generated method stub

cc.send();

}

}

java中的sleep是什么意思

SLEEP，英语单词，名词、动词，作名词时意为“睡眠，人名；(英)斯利普”，作动词时意为“睡，睡觉”。

单词发音英[sli_p]美[sli_p]基本用法sleep用作动词的基本意思是“睡眠”,也可作“为(某数量的人)提供床位”解。

sleep与介词to连用时一般都省略冠词。sleep用作名词的意思是“睡眠”,是不可数名词;加不定冠词时,表示“一段时间的睡眠”。

sleep的进行时可以表示按计划、安排或打算即将发生的动作,这时句中往往有表示将来的时间状语或特定的上下文。一站式出国留学攻略

java sleep(1000)和wait(1000)有区别吗？

第一种解释：\x0d\x0a\x0d\x0a功能差不多,都用来进行线程控制,他们最大本质的区别是:sleep()不释放同步锁,wait()释放同步缩. \x0d\x0a \x0d\x0a还有用法的上的不同是:sleep(milliseconds)可以用时间指定来使他自动醒过来,如果时间不到你只能调用interreput()来强行打断;wait()可以用notify()直接唤起.\x0d\x0a\x0d\x0a第二种解释：\x0d\x0a\x0d\x0asleep是Thread类的静态方法。sleep的作用是让线程休眠制定的时间，在时间到达时恢复，也就是说sleep将在接到时间到达事件事恢复线程执行，例如：\x0d\x0a\x0d\x0atry{\x0d\x0aSystem.out.println(“I’m going to bed”);\x0d\x0aThread.sleep(1000);\x0d\x0aSystem.out.println(“I wake up”);\x0d\x0a}\x0d\x0acatch(IntrruptedException e) {\x0d\x0a}\x0d\x0a\x0d\x0await是Object的方法，也就是说可以对任意一个对象调用wait方法，调用wait方法将会将调用者的线程挂起，直到其他线程调用同一个对象的notify方法才会重新激活调用者，例如：\x0d\x0a\x0d\x0a//Thread 1\x0d\x0a\x0d\x0atry{\x0d\x0aobj.wait();//suspend thread until obj.notify() is called\x0d\x0a}\x0d\x0acatch(InterrputedException e) {\x0d\x0a}\x0d\x0a\x0d\x0a第三种解释：\x0d\x0a\x0d\x0a这两者的施加者是有本质区别的. \x0d\x0asleep()是让某个线程暂停运行一段时间,其控制范围是由当前线程决定,也就是说,在线程里面决定.好比如说,我要做的事情是 “点火-烧水-煮面”,而当我点完火之后我不立即烧水,我要休息一段时间再烧.对于运行的主动权是由我的流程来控制.\x0d\x0a\x0d\x0a而wait(),首先,这是由某个确定的对象来调用的,将这个对象理解成一个传话的人,当这个人在某个线程里面说”暂停!”,也是 \x0d\x0athisOBJ.wait(),这里的暂停是阻塞,还是”点火-烧水-煮饭”,thisOBJ就好比一个监督我的人站在我旁边,本来该线\x0d\x0a程应该执行1后执行2,再执行3,而在2处被那个对象喊暂停,那么我就会一直等在这里而不执行3,但这个流程并没有结束,我一直想去煮饭,但还没被允许,\x0d\x0a \x0d\x0a直到那个对象在某个地方说”通知暂停的线程启动!”,也就是thisOBJ.notify()的时候,那么我就可以煮饭了,这个被暂停的线程就会从暂停处\x0d\x0a继续执行.\x0d\x0a\x0d\x0a其实两者都可以让线程暂停一段时间,但是本质的区别是一个线程的运行状态控制,一个是线程之间的通讯的问题\x0d\x0a\x0d\x0a在java.lang.Thread类中，提供了sleep()，\x0d\x0a而java.lang.Object类中提供了wait()， notify()和notifyAll()方法来操作线程\x0d\x0asleep()可以将一个线程睡眠，参数可以指定一个时间。\x0d\x0a而wait()可以将一个线程挂起，直到超时或者该线程被唤醒。\x0d\x0a wait有两种形式wait()和wait(milliseconds).\x0d\x0asleep和wait的区别有：\x0d\x0a 1，这两个方法来自不同的类分别是Thread和Object\x0d\x0a 2，最主要是sleep方法没有释放锁，而wait方法释放了锁，使得其他线程可以使用同步控制块或者方法。\x0d\x0a 3，wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，而sleep可以在\x0d\x0a 任何地方使用\x0d\x0a synchronized(x){\x0d\x0a x.notify()\x0d\x0a //或者wait()\x0d\x0a }\x0d\x0a 4,sleep必须捕获异常，而wait，notify和notifyAll不需要捕获异常

java sleep方法

调用方法：Thread.sleep(0);

括号内输入要睡眠的毫秒数(1秒等于1000毫秒)，调用这个方法会抛出异常，需要抛出或处理，它在睡眠被打断时发生。