Java多线程编程.docx
《Java多线程编程.docx》由会员分享，可在线阅读，更多相关《Java多线程编程.docx（11页珍藏版）》请在冰豆网上搜索。
Java多线程编程
Java多线程编程
如何实现多线程？
实现多线程的两种方法：
1，继承Thread类2，实现Runnable接口
例：
继承Thread类：
MultiThread.java:
publicclassMultiThread{
publicstaticvoidmain（String[]args）{
MyThreadmt=newMyThread（）;
mt.start（）;
System.out.println（Thread.currentThread（）.getName（））;
}
}
classMyThreadextendsThread{
publicvoidrun（）{
System.out.println（MyThread.currentThread（）.getName（））;
}
}
2：
实现Runnable接口：
Runnable1.java
publicclassRunnable1{
publicstaticvoidmain（String[]args）{
MyThread1mt=newMyThread1（）;
newThread（mt）.start（）;
System.out.println（Thread.currentThread（）.getName（））;
}
}
classMyThread1implementsRunnable{
publicvoidrun（）{
System.out.println（Thread.currentThread（）.getName（））;
}
}
线程的常用方法有哪些？
1，setDaemon（Booleanon）:
设置后台线程
2，yield（）:
在线运行的线程放弃运行权力。
3，Sleep（longmillis）：
线程睡眠，单位毫秒
4，同步（synchronized）:
同步方法和同步块，适用于并行线程共享临界资源
5，setPriority:
设置线程的优先级，大小从1到10，默认优先级NORM_PRIORITY（5）,最大：
MAX_PRIORITY（10），最小：
MIN_PRIORITY
（1）
6，wait：
每个对象除了有一个锁之外，还有一个等待队列（wait），当一个对象刚创建的时候，它的等待队列是空的。
7，我们应该在当前线程锁住对象的锁之后，去调用该对象的wait方法。
8，notify：
当调用对象的notify方法时，将从该对象的等待队列中删除一个任意选择的线程，这个线程将再次成为可运行的线程。
9，当调用对象的notifyAll方法时，将从该对象的等待队列中删除所有等待的线程，这些线程将成为可运行的线程。
Wait和notify主要用于生产者和消费者关系中。
例：
classTest
{
publicstaticvoidmain（String[]args）
{
Queueq=newQueue（）;
Producerp=newProducer（q）;
Consumerc=newConsumer（q）;
p.start（）;
c.start（）;
}
}
classProducerextendsThread
{
Queueq;
Producer（Queueq）
{
this.q=q;
}
publicvoidrun（）
{
for（inti=0;i<10;i++）
{
q.put（i）;
System.out.println（"Producerput"+i）;
}
}
}
classConsumerextendsThread
{
Queueq;
Consumer（Queueq）
{
this.q=q;
}
publicvoidrun（）
{
while（true）
{
System.out.println（"Consumerget"+q.get（））;
}
}
}
classQueue
{
intvalue;
booleanbFull=false;
publicsynchronizedvoidput（inti）
{
if（!
bFull）
{
value=i;
bFull=true;
notify（）;
}
try
{
wait（）;
}
catch（Exceptione）
{
e.printStackTrace（）;
}
}
publicsynchronizedintget（）
{
if（!
bFull）
{
try
{
wait（）;
}
catch（Exceptione）
{
e.printStackTrace（）;
}
}
bFull=false;
notify（）;
returnvalue;
}
}
多线程程序实例：
server端：
importjava.io.BufferedReader;
importjava.io.InputStreamReader;
importjava.io.PrintWriter;
import.ServerSocket;
import.Socket;
importjava.util.Collections;
importjava.util.concurrent.TimeUnit;
importjava.util.HashMap;
importjava.util.Map;
publicclassServerNet{
//以毫秒为单位
privatefinalstaticlongtimeLimit=10000;
privateMapmap=Collections.synchronizedMap（newHashMap（））;
publicvoidServerSocketNet（）{
try{
ServerSocketss=newServerSocket（6060）;
Sockets=ss.accept（）;
//用于获取客户端传输来的信息
BufferedReaderbuff=newBufferedReader（newInputStreamReader（s.getInputStream（）））;
//用于获取服务端准备响应的信息
BufferedReaderin=newBufferedReader（newInputStreamReader（System.in））;
//发送服务端准备响应的信息
PrintWriterpw=newPrintWriter（s.getOutputStream（）,true）;
pw.println（"您已经成功建立连接!
"）;
newServerOutNet（pw,in）;
newServerTimeListener（map,timeLimit）;
//显示客户端的传输来的信息
while（true）{
Stringstr=buff.readLine（）;
if（str.equals（"exit"））{
break;
}else{
map.put（ServerHelper.getInstance（）.getMapKey（）,str）;
System.out.println（str+" map.size:
"+map.size（））;
}
System.out.println（"ToClient:
"）;
Thread.sleep（100）;
}
s.close（）;
}catch（Exceptione）{
e.printStackTrace（）;
}
}
publicstaticvoidmain（String[]args）{
newServerNet（）.ServerSocketNet（）;
}
}
/**
*server发送线程向客户端发送响应信息
*@authorids-user
*
*/
classServerOutNetextendsThread{
privatePrintWriterprintWriter;
privateBufferedReaderbufferedReader;
ServerOutNet（PrintWriterpw,BufferedReaderin）{
this.printWriter=pw;
this.bufferedReader=in;
start（）;
}
publicvoidrun（）{
while（true）{
try{
StringinStr=bufferedReader.readLine（）;
if（inStr.equals（"exit"））{
printWriter.close（）;
bufferedReader.close（）;
break;
}else{
printWriter.println（"FromServer:
"+inStr）;
}
sleep（300）;
}catch（Exceptione）{
printWriter=null;
bufferedReader=null;
thrownewRuntimeException（e）;
}
}
}
}
//时间监听线程类。
classServerTimeListenerextendsThread{
privatelongtimeLimit;
Mapmap=newHashMap（）;
//单例
//privateServerTimeListener（）{}
//privatefinalstaticServerTimeListenerstl=newServerTimeListener（）;
//publicstaticServerTimeListenergetInstance（）{
// returnstl;
//}
ServerTimeListener（Mapmap,longtimeLimit）{
this.map=map;
this.timeLimit=timeLimit;
start（）;
}
publicvoidrun（）{
while（true）{
try{
//循环map
longcurrentTime=System.currentTimeMillis（）;
for（StringmapKey:
map.keySet（））{
longoldTime=Long.parseLong（mapKey.substring（0,mapKey.indexOf（"_"）））;
System.out.println（"currentTime-oldTime="+（currentTime-oldTime））;
if（currentTime-oldTime>=timeLimit）{
map.remove（mapKey）;
}
}
TimeUnit.MILLISECONDS.sleep（timeLimit）;
}catch（Exceptione）{
thrownewRuntimeException（e）;
}
}
}
}
服务器端辅助类：
ServerHelper
importjava.util.Random;
publicclassServerHelper{
//单例
privateServerHelper（）{}
privatefinalstaticServerHelperhelper=newServerHelper（）;
publicstaticServerHelpergetInstance（）{
returnhelper;
}
//构建map的key值
publicStringgetMapKey（）{
Randomrandom=newRandom（）;
StringmapKey=System.currentTimeMillis（）+"_"+random.nextInt（1000）;
System.out.println（"mapkey:
"+mapKey）;
returnmapKey;
}
}
Client端：
importjava.io.BufferedReader;
importjava.io.InputStreamReader;
importjava.io.PrintWriter;
import.Socket;
importjava.util.concurrent.Executors;
importjava.util.concurrent.ExecutorService;
publicclassClientNet{
publicstaticvoidmain（String[]args）{
try{
Sockets=newSocket（"127.0.0.1",6060）;
//用于获取服务端传输来的信息
BufferedReaderbuff=newBufferedReader（newInputStreamReader（s.getInputStream（）））;
//用于获取客户端准备响应的信息
BufferedReaderbufferedReader=newBufferedReader（newInputStreamReader（System.in））;
//发送客户端准备传输的信息
PrintWriterprintWriter=newPrintWriter（s.getOutputStream（）,true）;
printWriter.println（"有客房端请求连接!
"）;
//客户端使用线程池连接服务端
// ExecutorServiceexecutorService=Executors.newCachedThreadPool（）;
// executorService.execute（newClientOutNet（printWriter,bufferedReader））;
newClientOutNet（printWriter,bufferedReader）;
while（true）{//显示服务端的响应信息
Stringstr=buff.readLine（）;
if（str!
=null）{
System.out.println（str）;
}
// System.out.println（"ToServer:
"）;
Thread.sleep（100）;
}
}catch（Exceptione）{
e.printStackTrace（）;
}
}
}
/**
*Client发送线程，向服务端发送信息
*@authorids-user
*/
classClientOutNetextendsThread{
privatePrintWriterprintWriter;
privateBufferedReaderbufferedReader;
ClientOutNet（PrintWriterpw,BufferedReaderin）{
this.printWriter=pw;
this.bufferedReader=in;
start（）;
}
publicvoidrun（）{
while（true）{
try{
StringinStr=bufferedReader.readLine（）;
if（inStr.equals（"exit"））{
printWriter.close（）;
bufferedReader.close（）;
break;
}else{
printWriter.println（"FromClient:
"+inStr）;
}
sleep（300）;
}catch（Exceptione）{
printWriter=null;
bufferedReader=null;
thrownewRuntimeException（e）;
}
}
}
}
升级会员 