Java 学习笔记（四）

1. 建立 socket 连接。从 Socket 上读取数据。
	package com.bjfu.chapter11;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;
import java.net.UnknownHostException;

public class SocketReader {


	public void output() {
		
		try {
			Socket chatSocket = new Socket("127.0.0.1", 5000);
			PrintWriter writer = new PrintWriter(chatSocket.getOutputStream());
			
			writer.println("hello world!!!");
			writer.close();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	public static void main(String[] args) {

		try {
			Socket chatSocket = new Socket("127.0.0.1", 5000);
			InputStreamReader stream = new InputStreamReader(chatSocket.getInputStream());
			BufferedReader reader = new BufferedReader(stream);
			
			String line = null;
			while ((line = reader.readLine()) != null) {
				System.out.println(line);
			}
			reader.close();
					
		} catch (UnknownHostException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

}
2. 简单的 Socket ServerSocket 通讯程序。
	package com.bjfu.chapter11;

import java.io.*;
import java.net.Socket;

public class DailyAdviceClient {

	public void go() {
		
		try {
			Socket s = new Socket("127.0.0.1", 4242);
			InputStreamReader streamReader = new InputStreamReader(s.getInputStream());
			BufferedReader reader = new BufferedReader(streamReader);
			
			String advice  = reader.readLine();
			System.out.println("Today's advice is :" + advice);
			
			reader.close();
			
			
		} catch (Exception e) {
			
			e.printStackTrace();
		}
		
	}
	
	public static void main(String[] agrs) {
		DailyAdviceClient client = new DailyAdviceClient();
		client.go();
	}
}

package com.bjfu.chapter11;

import java.io.PrintWriter;
import java.net.*;

public class DailyAdviceServer {

	String[] adviceList = {"Take small bites",
			"Good morning", "hello world", "my god"
	};
	
	public void go() {
		
		try {
			
			ServerSocket serverSock = new ServerSocket(4242);
			
			while (true) {
				
				Socket sock = serverSock.accept();
				PrintWriter writer = new PrintWriter(sock.getOutputStream());
				String advice  = this.getAdvice();
				writer.println(advice);
				writer.close();
				System.out.println(advice);
			}
			
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	
	private String getAdvice() {
		
		return this.adviceList[(int) (Math.random() * this.adviceList.length)];
	}
	
	public static void main(String[] args) {
		
		DailyAdviceServer server = new DailyAdviceServer();
		server.go();
	}

}
3. Socket 代表两个应用程序时间的连接，他们可能会是在不同的机器上执行的。
	InputStreamReader 是个转换字节成字符的桥梁。它主要是用来连接BufferedReader 与底层的Socket 输入串流。
	
4. 每个Thread 需要一个任务来执行，一个可以放在执行空间的任务。

5. 一旦线程进入可执行状态，它会在可执行与执行中两种状态中来来去去，同时也有另外一种状态：暂时不可执行。
	（也称为阻塞状态）。
	
6.  线程调度器会决定哪个线程从等待状况中被挑出来运行，以及何时把哪个线程送回等待被执行的状态。

7. 线程会引发并发性（concurrency）导致竞争状态（race condition）。竞争状态会引发数据的损毁。
	也就是两个或两个以上的线程存取单一对象的数据。也就是两个不同执行空间上的方法都在堆上对同一对象进行操作。
	
8. synchronized 关键词代表线程需要一把钥匙来存取被同步化过的线程。要保护数据就把作用在数据上的方法同步。
	// 方法级别的锁
	private synchronized void  makeWithDrawal(int amount) {
		
		if (account.getBalance() > amount) {
			System.out.println(Thread.currentThread().getName() + " is abount withdraw.");
			try {
				
				System.out.println(Thread.currentThread().getName() + "  is going to sleep.");
				Thread.sleep(500);
			} catch (Exception e) {
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName() + " woke up.");
			account.withdraw(amount);
			System.out.println(Thread.currentThread().getName() + " complete the withdraw.");
			
		} else {
			System.out.println("Sorry, not enough for " + Thread.currentThread().getName());
		}
		
		
	}
9. 使用对象的锁。每个对象都有一个锁。对象的锁只会在有同步化的方法上起作用。线程只有在取得对象锁的
	钥匙时才能进入同步化的方法。如果对象有同步化的方法，则线程只能在取得钥匙的情况下进入线程。
	
10. 对象就算是有多个同步化过的方法，也还是只有一个锁。一旦某个线程进入该对象的同步化方法，其他线程就
	无法进入该对象上的任何同步化线程。

11. 静态变量的状态更新保护，也可以同步化。因为每个被载入的类都有一个锁。