JAVA实现网络编程之并发编程
一.并发与并行
个人理解并发就是在时间上运行程序（即不同任务在不同时间片上运行），并行就是在空间上运行程序（即不同任务在不同处理器或计算机上运行）。
二.Java中的Thread类
1.Thread类通过实现Runnable接口
2.线程池(ThreadPool)用来管理线程的数量
我们先用一个例子实现:
1.创建并启动100个线程，每个线程都往同一个账户添加一元。
2.定义一个名为Account类模拟账户，一个名为AddAYuanTask的类用来向账户里添加一元。
程序如下
第一版Account
第一版Account
1 import java.util.concurrent.*;
2
3 public class AccountWithoutSync {
4 private static Account account = new Account();
5
6 public static void main(String[] args)
7 {
8 ExecutorService executor = Executors.newCachedThreadPool();
9
10 for(int i = 0; i < 100; i++)
11 {
12 executor.execute(new AddOneYuanTask());
13 }
14
15 executor.shutdown();
16
17 while(!executor.isTerminated())
18 {
19
20 }
21
22 System.out.println("What is balance? " + account.getBalance());
23 }
24
25 //Inner class
26 private static class AddOneYuanTask implements Runnable
27 {
28 public void run()
29 {
30 account.deposit(1);
31 }
32 }
33
34 private static class Account
35 {
36 private int balance = 0;
37
38 public int getBalance()
39 {
40 return balance;
41 }
42
43 public void deposit(int amount)
44 {
45 int newBalance = balance + amount;
46
47 //人为地制造延时
48 try
49 {
50 Thread.sleep(5);
51 }
52 catch(InterruptedException ex)
53 {
54 }
55
56 balance = newBalance;
57 }
58 }
59 }
我们运行一下发现balance为4或5，这是个错误的结果，如果一个类的对象在多线程程序中导致竞争状态，则称这个类为线程不安全的。所以这个任务是线程不安全的。
三.用同步完善程序
用互斥锁来实现同步，即在一任务开始执行时加锁，执行完毕后释放锁。在释放锁之前其它任务无法执行。同步完全可以避免竞争状态的产生，但有的时候还需要线程之间的相互合作。
然后增加一个向账户提款(Withdraw)的任务，当余额小于取款数时，等待新存入的存款。
Account类添加
private static Lock lock = new ReentrantLock(); //创建一个锁
private static Condition newDeposit = lock.newCondition(); //实现一个条件
Account类中应用互斥锁的的方法如下
withdraw和deposit然后程序相应的修改修改
第二版Account
1 public static void main(String[] args)
2 {
3 System.out.println("Thread 1\t\tThread 2\t\tBalance");
4
5 ExecutorService executor = Executors.newFixedThreadPool(2);
6 executor.execute(new DepositTask());
7 executor.execute(new WithdrawTask());
8 executor.shutdown();
9 }
10
11
12 public static class DepositTask implements Runnable
13 {
14 public void run()
15 {
16 try
17 {
18 while(true)
19 {
20 account.deposit((int)(Math.random() * 10) + 1);
21 Thread.sleep(1000);
22 }
23 }
24 catch(InterruptedException ex)
25 {
26 ex.printStackTrace();
27 }
28 }
29 }
30
31 public static class WithdrawTask implements Runnable
32 {
33 public void run()
34 {
35 while(true)
36 {
37 account.withdraw((int)(Math.random() * 10) + 1);
38 }
39 }
40 }
四.客户端/服务器的网络应用
Java中对socket的使用十分方便，在建立socket连接后就可以使用输入输出流的方法实现数据传输了。
在实现基本的GUI后，在服务器用一个判断条件永远为true的循环来监听客户端的连接请求(Socket socket = serverSocket.accept();
服务器通过创建一个内部类(HandleAClient)，把客服端的socket传递过来执行。
HandleAClient类
1 class HandleAClient implements Runnable
2 {
3 //A connected socket
4 private Socket socket;
5
6 /**Construct a thread */
7 public HandleAClient(Socket socket)
8 {
9 this.socket = socket;
10 }
11
12 /**Run a thread */
13 public void run()
14 {
15 try
16 {
17 //Create data input and output streams
18 DataInputStream inputFromClient = new DataInputStream(
19 socket.getInputStream());
20 DataOutputStream outputToClient = new DataOutputStream(
21 socket.getOutputStream());
22 int order = 0;
23 double amount;
24 //Continuously serve the client
25 while(order != 4)
26 {
27 //Receive order, amount from the client
28 order = inputFromClient.readInt();
29 amount = inputFromClient.readDouble();
30
31 if(order == 1)
32 {
33 outputToClient.writeDouble(account.getBalance());
34 }
35 else if(order == 2)
36 {
37 account.withdraw(amount);
38 outputToClient.writeDouble(account.getBalance());
39 }
40 else if(order == 3)
41 {
42 account.deposit(amount);
43 outputToClient.writeDouble(account.getBalance());
44 }
45
46 jta.append("Order received from client: "+
47 order + '\n');
48 jta.append("Balance is " + account.getBalance() + '\n');
49 }
50 }
51 catch(IOException e)
52 {
53 System.err.println(e);
54 }
55 }
56 }
而客户端连接上服务器后，创建两个IO流
//IO streams
DataOutputStream toServer = new DataOutputStream(socket.getOutputStream());
DataInputStream fromServer = new DataInputStream(socket.getInputStream());
即可传输order(菜单选项)和amount
//Send the order, amount to the server
toServer.writeInt(order);
toServer.writeDouble(amount);
toServer.flush();
最后再读取balance
balance = fromServer.readDouble();
