Java 线程中的异常-多线程乐透程序

我遇到了一个无法解决的异常

package advanced.net;

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.InetAddress;
import java.net.Socket;

public class LottoClient {

    private InetAddress serverAddress;

    private int serverPort = LottoProtocol.SERVER_PORT;

    public static void main(String[] args) {
        System.out.println("Starting Client");
        LottoClient lottoClient1 = null;
        lottoClient1 = new LottoClient(); // This was not a TODO
        lottoClient1.startClient(args);
    }

    public LottoClient() {
    }

    private String getTicketFromServer() {
        String lotteryTicket = null;
        BufferedReader reader = null; // to get response from server
        PrintWriter writer = null; // to send request to server
        System.out.println("Getting Ticket");
        try {
            Socket socket = new Socket(serverAddress, serverPort);

            InputStream in = socket.getInputStream();
            OutputStream out = socket.getOutputStream();

            reader = new BufferedReader(new InputStreamReader(in));
            writer = new PrintWriter(out, true); // true for autoflush

            lotteryTicket = reader.readLine(); // read the response
        } catch (java.io.IOException e) {
            System.err.println("Error getting ticket");
            e.printStackTrace();
        } finally {
            try {
                if (reader != null) {
                    reader.close();
                }
                if (writer != null) {
                    writer.close();
                }
            } catch (java.io.IOException e) {
                e.printStackTrace();
            }
        }

        // TODO 08. Return the lottery ticket String.
        return lotteryTicket;
    }

    /**
     * configData[0] is the name or IP address of the server
     */
    private void processConfigData(String configData[]) {
        try {
            // set address of server
            if (configData != null && configData.length >= 1) {
                serverAddress = InetAddress.getByName(configData[0]);
            } else {
                // default case is set in our protocol
                String host = LottoProtocol.SERVER_HOST;
                serverAddress = InetAddress.getByName(host);
            }
        } catch (java.net.UnknownHostException e) {
            e.printStackTrace();
        }
    }

    public void startClient(String args[]) {
        processConfigData(args);
        String lottoTicket = getTicketFromServer();
        System.out.println(lottoTicket);
    }
}

package advanced.net;

import java.util.*;
import java.net.*;
import java.io.*;

public class LottoServer {

    // TODO 01. Make the handler a subclass of Thread.
    private class ClientRequestHandler extends Thread {

        private Socket socket = null;

        public ClientRequestHandler() {
            // Default Constructor
        }

        public ClientRequestHandler(Socket clientSocket) {
            socket = clientSocket;
        }

        /**
         * Generate a lotto ticket. Returns a formatted string containing 6
         * numbers from 1 to 49.
         */
        private String getTicket() {
            int theNumbers[] = new int[LottoProtocol.NUM_OF_NUMBERS];

            for (int i = 0; i < LottoProtocol.NUM_OF_NUMBERS; i++) {
                int newNumber;
                boolean isDuplicate = false;
                do {
                    isDuplicate = false; // reset isDuplicate, in case it has
                    // been set to true

                    // we want the numbers to be in the range of 1 to maxValue
                    // 0 to 48, and then add 1 to make it 1 to 49
                    newNumber = (int) (numberGenerator.nextDouble()
                            * (LottoProtocol.MAX_VALUE - 1) + 1);

                    // Compare to the numbers entered previously, to make sure
                    // it is
                    // not a duplicate.
                    // If it is, then ignore it, and get a new random number.
                    for (int j = 0; j < i && !isDuplicate; j++) {
                        if (newNumber == theNumbers[j]) {
                            isDuplicate = true;
                        }
                    }
                } while (isDuplicate);

                theNumbers[i] = newNumber;
            }
            Arrays.sort(theNumbers);
            StringBuffer sb = new StringBuffer();
            sb.append("Your numbers are: ");
            for (int k = 0; k < LottoProtocol.NUM_OF_NUMBERS; k++) {
                sb.append(String.valueOf(theNumbers[k]) + " ");
            }
            return sb.toString();
        }

        private void handleClientRequests() {
            BufferedReader reader = null; // to read client requests
            PrintWriter writer = null; // to send back response
            String request;

            try {
                InputStream in = socket.getInputStream();
                OutputStream out = socket.getOutputStream();

                reader = new BufferedReader(new InputStreamReader(in));
                writer = new PrintWriter(out, true); // true for autoflush

                writer.println("LottoServer 1.2");
                request = reader.readLine(); // read client request
                if (request
                        .equalsIgnoreCase(LottoProtocol.TICKET_REQUEST_COMMAND)) {
                    writer.println(getTicket()); // process the request
                }
            } catch (IOException ioe) {
                System.err.println("Error processing the request");
                ioe.printStackTrace();
            } finally {
                try {
                    if (reader != null) {
                        // TODO 05. Close the reader.
                        reader.close();
                    }
                    if (writer != null) {
                        // TODO 06. Close the writer.
                        writer.close();
                    }
                    if (socket != null) {
                        // TODO 07. Close the client socket.
                        socket.close();
                    }
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        }

        public void run() {
            handleClientRequests();
        }

        public Socket getSocket() {
            return socket;
        }

        public void setSocket(Socket socket) {
            this.socket = socket;
        }
    }

    public static void main(String[] args) {
        LottoServer lottoServer1 = new LottoServer();
        lottoServer1.startServer();
    }

    private Random numberGenerator = new Random(System.currentTimeMillis());

    private ServerSocket serverSocket = null;

    public LottoServer() {
    }

    private void acceptConnections() {
        Socket clientSocket;
        while (true) {
            try {
                // TODO 02. Get the socket from the client.
                System.out.println("Socket Empty");
                clientSocket = null;
                clientSocket = serverSocket.accept();
                System.out.println("Socket Captured");
                // TODO 03. Create a new instance of the handler.
                ClientRequestHandler handler = null;
                handler = new ClientRequestHandler();
                System.out.println("Handler Created");
                handler.setSocket(clientSocket);
                Thread thread = new Thread(handler);
                System.out.println("Thread Created");
                // TODO 04. Start the new thread.
                thread.start();
                System.out.println("Thread Started Created");
            } catch (java.io.IOException e) {
                System.err.println("Error setting up connection");
                e.printStackTrace();
            }
        }
    }

    private void createServerSocket() {
        try {
            serverSocket = new ServerSocket(LottoProtocol.SERVER_PORT);
            System.out.println("Socket Created");
        } catch (java.io.IOException e) {
            String error = "Error setting up connection" + e.getMessage();
            System.err.println(error);
        }
    }

    public void startServer() {
        System.out.println("Server Started");
        createServerSocket();
        acceptConnections();
    }

}

package advanced.net;

public class LottoProtocol {

    public static final int MAX_VALUE = 49;

    public static final int NUM_OF_NUMBERS = 6;

    public static final String SERVER_HOST = "localhost";

    public static final int SERVER_PORT = 5123;

    public static final String TICKET_REQUEST_COMMAND = "GetTicket";
}

package advanced.net；
导入java.io.BufferedReader；
导入java.io.InputStream；
导入java.io.InputStreamReader；
导入java.io.OutputStream；
导入java.io.PrintWriter；
导入java.net.InetAddress；
导入java.net.Socket；
公共类乐透客户机{
私有地址服务器地址；
private int serverPort=LottoProtocol.SERVER\u端口；
公共静态void main（字符串[]args）{
System.out.println（“启动客户端”）；
LottoClient lottoClient1=null；
lottoClient1=new LottoClient（）；//这不是待办事项
lottoClient1.startClient（args）；
}
公共乐透客户（）{
}
私有字符串getTicketFromServer（）{
字符串lotteryTicket=null；
BufferedReader reader=null；//从服务器获取响应
PrintWriter=null；//向服务器发送请求
System.out.println（“获取票证”）；
试一试{
套接字=新套接字（服务器地址、服务器端口）；
InputStream in=socket.getInputStream（）；
OutputStream out=socket.getOutputStream（）；
reader=新的BufferedReader（新的InputStreamReader（in））；
writer=新的PrintWriter（out，true）；//对于自动刷新为true
lotteryTicket=reader.readLine（）；//读取响应
}捕获（java.io.ioe异常）{
System.err.println（“获取票据时出错”）；
e、 printStackTrace（）；
}最后{
试一试{
if（读卡器！=null）{
reader.close（）；
}
if（writer！=null）{
writer.close（）；
}
}捕获（java.io.ioe异常）{
e、 printStackTrace（）；
}
}
//TODO 08.返回彩票字符串。
回程彩票；
}
/**
*configData[0]是服务器的名称或IP地址
*/
私有void processConfigData（字符串configData[]）{
试一试{
//设置服务器的地址
if（configData！=null&&configData.length>=1）{
serverAddress=InetAddress.getByName（configData[0]）；
}否则{
//在我们的协议中设置了默认情况
字符串主机=LottoProtocol.SERVER\u主机；
serverAddress=InetAddress.getByName（主机）；
}
}catch（java.net.UnknownHostException e）{
e、 printStackTrace（）；
}
}
public void startClient（字符串参数[]）{
processConfigData（args）；
字符串lototicket=getTicketFromServer（）；
系统输出打印LN（乐透测试）；
}
}
包高级.net；
导入java.util.*；
导入java.net。*；
导入java.io.*；
公共类彩票服务器{
//TODO 01.使处理程序成为线程的子类。
私有类ClientRequestHandler扩展线程{
私有套接字=空；
公共ClientRequestHandler（）{
//默认构造函数
}
公共ClientRequestHandler（套接字clientSocket）{
socket=clientSocket；
}
/**
*生成乐透彩票。返回包含6的格式化字符串
*数字从1到49。
*/
私有字符串getTicket（）{
int theNumbers[]=新int[LottoProtocol.NUM_OF_number]；
for（int i=0；irequest = reader.readLine(); // read client request

if (request.equalsIgnoreCase(LottoProtocol.TICKET_REQUEST_COMMAND)) {

if (LottoProtocol.TICKET_REQUEST_COMMAND.equalsIgnoreCase(request)) {