关于线程的存活期（多线程）以及结束主线程中的子线程

Question

        private Socket mySock;
        private TcpListener tcpL;
        private System.Net.IPAddress MyIP = System.Net.IPAddress.Parse("-_-！！");
        private NetworkStream netStream;
        private Thread tMain;        private const int m_nArrayCapacity = 512;
        private Hashtable m_htThreads = new Hashtable(m_nArrayCapacity);
        private ArrayList m_listSockets = new ArrayList(m_nArrayCapacity);
//启动 
private void button1_Click(object sender, EventArgs e)
        {
            tcpL = new TcpListener(MyIP, 1314);
            tcpL.Start();
            tMain = new Thread(new ThreadStart(waitConnect));
            tMain.Start();
        }
//主线程Start函数
private void waitConnect()
        {            while (true)
            {
               
                mySock = tcpL.AcceptSocket();
                
                if (mySock.Connected)
                {
                    IPEndPoint ipe = (IPEndPoint)(mySock.RemoteEndPoint);
                    String sKey = ipe.Address.ToString() + ":" + ipe.Port.ToString();
                    Thread tClient = new Thread(new ThreadStart(receive));
                    Monitor.Enter(this);
                    m_htThreads.Add(sKey, tClient);
                    Monitor.Exit(this);
                    tClient.IsBackground = true;
                    tClient.Start();
 
                    
                }
            }
        }
//子线程接收函数
private void receive()
        {
            Socket sock = null;
            Thread temT = null;
            sock = mySock;
            IPEndPoint ipe = (IPEndPoint)(sock.RemoteEndPoint);
            String sKey = ipe.Address.ToString() + ":" + ipe.Port.ToString();
            Monitor.Enter(this);
            m_htSockets.Add(sKey, sock);
            Monitor.Exit(this);
            
            while (true)
            {
                try
                {
                                        
                    byte[] bb = new byte[1024];
                    int bytesread = sock.Receive(bb);
                    if (bytesread != 0)//客户端主动断开连接
                    {
                        string msgFromClient =
                            System.Text.Encoding.Default.GetString(bb, 0, bytesread);
                        Addtext(msgFromClient, 1);
                    }
                    else
                    {
                        sock.Shutdown(SocketShutdown.Both);
                        sock.Close();
                        //这里省略删除hashtable和arraylist中的数据的函数
                        return;//return之后这个子线程是不是就自动结束了？如果没有我还需要做些什么
                    }
                }
                catch(Exception ee)
                {
                    if (sock != null)
                    {
                        try
                        {
                            sock.Shutdown(SocketShutdown.Both);    
                        }
                        catch (Exception) { }
                        sock.Close();
                        //这里省略删除hashtable和arraylist中的数据的函数
                    }
                    return;//return之后这个子线程是不是就自动结束了？如果没有我还需要做什么
                }
            }
        }//关闭
private void button2_Click(object sender, EventArgs e)
        {
            //if netStream
            lock (this)
           {
            try
            {
                Thread.Sleep(200);
                for (int i = m_listSockets.Count - 1; i >= 0; i--)
                {
                    Socket sock = null;
                    IPEndPoint ipe = null;
                    Thread temT = null;
                    sock = (Socket)(m_listSockets[i]);
                    if (sock.Connected)
                    {
                        ipe = (IPEndPoint)(sock.RemoteEndPoint);
                        String sKey = ipe.Address.ToString() + ":" + ipe.Port.ToString();
                        temT = (Thread)m_htThreads[sKey];
                        if (temT.IsAlive)
                        {
                            temT.Abort();
                        }
                        sock.Shutdown(SocketShutdown.Both);
                        sock.Close();
                        temT.Join();//如果我不把temT进行Abort()和Join()我发现线程在对应socket关闭后也既然也自动关闭了
                        temT = null;
                    }
                }
            }
            catch(Exception ee)
            {
                MessageBox.Show(ee.Message);
            }
            finally
            {
                m_htSockets.Clear();
                m_htThreads.Clear();
            }
            if(mySock!=null)
               mySock.Close();
            tMain.Abort();
            tcpL.Stop();
            tMain.Join();
        }
}
以上是多线程的服务端的简单代码，我现在主要迷茫的地方是这些子线程在我关掉socket连接后会自己结束么？怎么才能彻底结束主线程中的子线程？如果有个线程如下
Thread t = new Thread(new ThreadStart(test));                    t.Start();
void test()
｛
   string x＝"test";
｝
这样的线程是不是执行完后就自动结束了？
只是将线程Abort()的 话线程还会占用系统资源么？

Answer 1

1:return之后这个子线程是不是就自动结束了？如果没有我还需要做些什么 
是的。
2:你的这段代码
Thread t = new Thread(new ThreadStart(test)); 
t.Start(); 
void test() 
｛ 
  string x＝"test"; 
｝ 
这样的线程是不是执行完后就自动结束了？ 
是的。线程结束了。
3:只是将线程Abort()的 话线程还会占用系统资源么？
Abort()只是向线程发出一个异常。线程在收到这个异常后“理应”结束，但是否结束完全取决于程序的具体实现，比如：线程可能正处于阻塞状态操作进行某一个托管的操作，这时的Abort()不会立刻终止线程。
正确的方法你已经写了
t.Abort();
t.Join(1000);
终止的线程不会占据线程的资源。

Answer 2

至于你说的socket关闭，请你仔细检查你的thread中是否产生了异常。线程如果发生异常未处理也会导致线程中止。

Answer 3

1:return之后这个子线程是不是就自动结束了？如果没有我还需要做些什么？
--------结束了。 2:你的这段代码 
Thread t = new Thread(new ThreadStart(test)); 
t.Start(); 
void test() 
｛ 
  string x＝"test"; 
｝ 
这样的线程是不是执行完后就自动结束了？ 
---------是的。线程结束了。
 
3:只是将线程Abort()的 话线程还会占用系统资源么？ 
---------Abort()只是向线程发出一个异常。线程在收到这个异常后“理应”结束，但是否结束完全取决于程序的具体实现。

Answer 4

谢谢phy 的耐心解答，现在豁然间想通了呵呵。