多线程+socket+文件读写<二>

线程的阻塞
阻塞指的是暂停一个线程的执行以等待某个条件发生（如某资源就绪），Java 提供了大量方法来支持阻塞，下面让我们逐一分析。
    1. sleep() 方法：sleep() 允许指定以毫秒为单位的一段时间作为参数，它使得线程在指定的时间内进入阻塞状态，不能得到CPU 时间，指定的时间一过，线程重新进入可执行状态。
    2. suspend() 和 resume() 方法：两个方法配套使用，suspend()使得线程进入阻塞状态，并且不会自动恢复，必须其对应的resume() 被调用，才能使得线程重新进入可执行状态。
    3. yield() 方法：yield() 使得线程放弃当前分得的 CPU 时间，但是不使线程阻塞，即线程仍处于可执行状态，随时可能再次分得 CPU 时间。
    4. wait() 和 notify() 方法：两个方法配套使用，wait() 使得线程进入阻塞状态，它有两种形式，一种允许指定以毫秒为单位的一段时间作为参数，另一种没有参数，前者当对应的 notify() 被调用或者超出指定时间时线程重新进入可执行状态，后者则必须对应的 notify () 被调用。
区别:
初看起来 wait() 和 notify()与 suspend() 和 resume() 方法对没有什么分别，但是事实上它们是截然不同的。区别的核心在于，前面叙述的所有方法，阻塞时都不会释放占用的锁（如果占用了的话），而 wait() 和 notify()这一对方法则相反, wait() 方法导致线程阻塞，并且该对象上的锁被释放。
在上面的实例中修改:
    public static void main(String[] args) {
        Thread1 t1 = new Thread1();
        Thread ta = new Thread(t1, "A");
        Thread tb = new Thread(t1, "B");
        ta.start();
        try {
            ta.sleep(10000);
        }
        catch (Exception e) {}
       
        tb.start();
    }
在输出A的5条记录后,须等10秒,才输出B的.
若用wait(),则直接输出A,B信息.

JAVA多线程编程。用JAVA写一个多线程程序，如写四个线程，二个加1，二个对一个变量减一，输出。(须考虑同步)
//将要加减的变量设置为static;将加减操作及相应的变量定义在另一类中.在线程中进行调用即可.
//只要是多线程,就要考虑其同步.即要用synchrnized
class t
{
    private static int x=10;
    public synchronized void add()
    {
        x++;
        System.out.println("x="+x);
    } 
    public synchronized void jian()
    {
        x--;
        System.out.println("x="+x);
    }
}
class t1 extends Thread
{
 public void run()
 {
  t t1=new t();
  t1.add();
 }     
}
class t2 extends Thread
{
 public void run()
 {
  t t1=new t();
  t1.jian();
 }
}
public class ThreadTest
{
    public static void main(String [] args)
    {
        t1 t11=new t1();
        t1 t12=new t1();
        t2 t21=new t2();
        t2 t22=new t2();
        t11.start();
        t12.start();
        t21.start();
        t22.start();
    }
}

5.
线程池
线程池就像数据库连接池一样，是一个对象池。所有的对象池都有一个共同的目的，那就是为了提高对象的使用率，从而达到提高程序效率的目的.

多线程---守护线程
在Java中有两类线程：User Thread(用户线程)、Daemon Thread(守护线程)
        Daemon的作用是为其他线程的运行提供便利服务，比如垃圾回收线程就是一个很称职的守护者。
6.
终止线程三种方式:
当run方法完成后线程终止;
使用stop方法强行终止线程（这个方法不推荐使用，因为stop和suspend、resume一样，也可能发生不可预料的结果）;
使用interrupt方法中断线程.

 

------------------------------------文件读写----------------------------------
I/O操作
对于输入/输出问题，Java将之抽象化为流(Stream)对象来解决。
对输入/输出流,及文件的处理,注意要在最后关闭流或文件,且在处理前后添加try..catch.

Reader、Writer与其子类可以用于进行所谓纯文本文件的字符读/写.
InputStreamReader和OutputStreamWriter (它们分别为Reader和Writer的子类.)
InputStreamReader inputStreamReader = new InputStreamReader(fileInputStream); 
OutputStreamWriter outputStreamWriter = new OutputStreamWriter(fileOutputStream);
            int ch = 0;   
            // 以字符方式显示文件内容   
            while ((ch = inputStreamReader.read()) != -1) {   
                outputStreamWriter.write(ch);   
            }   
            inputStreamReader.close();   
            outputStreamWriter.close();   
    
FileReader和FileWriter(它们分别继承自InputStreamReader与 OutputStreamWriter)
                       操作更加简单,不用先建input/outputstream,直接将路径放上去就行.
FileReader fileReader = new FileReader("D:\\jason.txt");
FileWriter fileWriter = new FileWriter("D:\\change.txt");

BufferedReader和BufferedWriter(常用于整行读写,单字读写用上面的两类)
读写效率比较高,但须先创建InputStreamReader/OutputStreamWriter或FileReader/FileWriter作为其参数
try {   
            BufferedReader reader=new BufferedReader(new FileReader("D:\\jason.log"));
            BufferedWriter writer=new BufferedWriter(new FileWriter("D:\\change.txt"));
            String show=reader.readLine(); //读取第一行信息
            while(!show.equals("bye"))
            {
             System.out.println(show);
             writer.write(show+"\n");   //其中\n用于换行
                show=reader.readLine();   //进行循环读取
            }
            writer.flush();
            reader.close();
            writer.close();
        } catch (Exception ee) {   
            ee.printStackTrace();   
        }
注意：只有BufferedReader或BufferedInputStream，没有BufferedInputStreamReader.

说明:
BufferedReader的readline()方法,实际就是以下的样式的定制:
byte[] a=new byte[2];   --->自己定制缓存的大小,而readline(),则是原先定制好的.
.....
if((ch=A.read(a))!=-1)
{B.wirte(a)}

 

------------------------------------socket----------------------------------
socket,
对输入/输出流,及文件的处理,注意要在最后关闭流或文件,且在处理前后添加try..catch

我们可以做一个简单的 Socket 例程了 . 
服务端 : 
import java.io.*; 
import java.net.*; 
public class MyServer { 
public static void main(String[] args) throws IOException{ 
  ServerSocket server=new ServerSocket(5678); 
  Socket client=server.accept(); 
BufferedReader in=new BufferedReader(new InputStreamReader(client.getInputStream())); 
PrintWriter out=new PrintWriter(client.getOutputStream()); 
while(true){ 
String str=in.readLine(); 
System.out.println(str); 
out.println("has receive...."); 
out.flush(); 
if(str.equals("end")) 
break; 
} 
client.close(); 
} 
} 

注意：只有BufferedReader或BufferedInputStream，没有BufferedInputStreamReader.

 
       这个程序的主要目的在于服务器不断接收客户机所写入的信息直到客户机发送 "End" 字符串就退出程序 . 并且服务器也会做出 "Receive" 为回应 . 告知客户机已接收到消息 . 
客户机代码 : 
import java.net.*; 
import java.io.*; 
public class Client{ 
static Socket server; 
public static void main(String[] args)throws Exception{ 
  server=new Socket(InetAddress.getLocalHost(),5678); 
  BufferedReader in=new BufferedReader(new InputStreamReader(server.getInputStream())); 
  PrintWriter out=new PrintWriter(server.getOutputStream()); 
  BufferedReader wt=new BufferedReader(new InputStreamReader(System.in)); 
   
  while(true){ 
   String str=wt.readLine(); 
   out.println(str); 
   out.flush(); 
   if(str.equals("end")){ 
    break; 
   } 
   System.out.println(in.readLine()); 
  } 
  server.close(); 
} 
} 
这个程序只是简单的两台计算机之间的通讯 . 如果是多个客户同时访问一个服务器呢 ? 你可以试着再运行一个客户端 , 结果是会抛出异常的 . 那么多个客户端如何实现呢 ? 

如何实现多线程并发socket通讯:
服务端socket,负责监听socket端口,设置一个无限循环,在其中实现:将监听到的socket实例赋给线程且启动线程,由线程来完成业务逻辑.具体如下:

import java.net.*; 
import java.io.*; 
public class MultiUser extends Thread{ 
private Socket client; 
public MultiUser(Socket c){ 
  this.client=c; 
} 
public void run(){ 
  try{   
   BufferedReader in=new BufferedReader(new InputStreamReader(client.getInputStream())); 
   PrintWriter out=new PrintWriter(client.getOutputStream()); 
    //Mutil User but can't parallel 
    while(true){ 
     String str=in.readLine(); 
     System.out.println(str); 
     out.println("has receive...."); 
     out.flush(); 
     if(str.equals("end")) 
      break; 
    } 
   client.close();   
   }catch(IOException ex){ 
   }finally{ 
     
   } 
} 

myserver.java修改如下:
public static void main(String[] args)throws IOException{ 
  ServerSocket server=new ServerSocket(5678); 
  while(true){ 
   //transfer location change Single User or Multi User 
   MultiUser mu=new MultiUser(server.accept()); 
   mu.start(); 
  } 
} 
} 
2.
用socket传输文件，实际就是打开文件，将内容读取发送到对方，对方获取保存到文件中。
用socket可以传输对象--ObjectInputStream/ObjectOutputStream

1.          对于普通的传输字符串，用 BufferedInputStream /BufferedOutputStream 及 os.println(), is.readline() 即可。
2.          对于文件的传输，用 FileInputStream /FileOutputStream 及 DataInputStream /DataOutputStream 及 os.write(), is.read() 即可。
3.          对于对象的传输，用 ObjectInputStream /ObjectOutputStream 及 os.writeObject(), is.readObject() 即可 .

public class FileSender {

  private ServerSocket ss = null;

  public FileSender() {

  }

  public void startSend(String filePath, int port) {
    // socket输出流
    DataOutputStream os = null;
    // 文件输入流
    DataInputStream is = null;
    // 建立socket连接
    Socket socket = null;
    try {
      // 选择进行传输的文件
      File file = new File(filePath);

      // 建立socket监听
      ss = new ServerSocket(port);

      socket = ss.accept();

      os = new DataOutputStream(socket.getOutputStream());

      // 将文件名及长度传给客户端。这里要真正适用所有平台，例如中文名的处理，还需要加工，
      // 具体可以参见Think In Java 4th里有现成的代码。
      os.writeUTF(file.getName());
      os.flush();
      os.writeLong((long) file.length());
      os.flush();

      is = new DataInputStream(new BufferedInputStream(
          new FileInputStream(filePath)));
      // 缓冲区大小
      int bufferSize = 8192;
      // 缓冲区
      byte[] buf = new byte[bufferSize];
      // 传输文件
      while (true) {
        int read = 0;
        if (is != null) {
          read = is.read(buf);
        }

        if (read == -1) {
          break;
        }
        os.write(buf, 0, read);
      }
      os.flush();

    } catch (IOException e) {
      e.printStackTrace();
    } finally {
      // 关闭所有连接
      try {
        if (os != null)
          os.close();
      } catch (IOException e) {
      }
      try {
        if (is != null)
          is.close();
      } catch (IOException e) {
      }
      try {
        if (socket != null)
          socket.close();
      } catch (IOException e) {
      }
      try {
        if (ss != null)
          ss.close();
      } catch (IOException e) {
      }
    }

  }

  public static void main(String[] args) {
    new FileSender().startSend("E:\\JDK_API_1_6_zh_CN.CHM", 8821);
  }
}

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.net.Socket;
import java.net.UnknownHostException;

public class FileIncepter {

  public FileIncepter() {

  }

  public void getFile(String savePath, String ip, int port) {
    // 建立socket连接
    Socket socket = null;
    try {
      socket = new Socket(ip, port);
    } catch (UnknownHostException e1) {
      e1.printStackTrace();
    } catch (IOException e1) {
      e1.printStackTrace();
    }
    // 建立socket输入流
    DataInputStream inputStream = null;
    try {
      inputStream = new DataInputStream(new BufferedInputStream(socket
          .getInputStream()));
    } catch (IOException e1) {
      e1.printStackTrace();
    }
    try {
      // 缓冲区大小
      int bufferSize = 8192;
      // 缓冲区
      byte[] buf = new byte[bufferSize];
      int passedlen = 0;
      long len = 0;
      // 获取文件名称
      savePath += inputStream.readUTF();
      DataOutputStream fileOut = new DataOutputStream(
          new BufferedOutputStream(new BufferedOutputStream(
              new FileOutputStream(savePath))));
      // 获取文件长度
      len = inputStream.readLong();

      System.out.println("文件的长度为:" + len + "    KB");
      System.out.println("开始接收文件!");

      // 获取文件
      while (true) {
        int read = 0;
        if (inputStream != null) {
          read = inputStream.read(buf);
        }
        passedlen += read;
        if (read == -1) {
          break;
        }
        System.out.println("文件接收了" + (passedlen * 100 / len) + "%");
        fileOut.write(buf, 0, read);
      }
      System.out.println("接收完成，文件存为" + savePath);
      fileOut.close();
    } catch (Exception e) {
      e.printStackTrace();
      return;
    }
  }

  public static void main(String[] args) {
    new FileIncepter().getFile("F:\\", "localhost", 8821);
  }
}

本文出自 51CTO.COM技术博客