//方式一
publicclassMyThreadextendsThread{
　　publicvoidrun(){
　　System.out.println("MyThread.run()");
　　}
}
//在合适的地方启动线程如下：
MyThreadmyThread1=newMyThread();
MyThreadmyThread2=newMyThread();
myThread1.start();
myThread2.start();

//方式二
publicclassMyThreadextendsOtherClassimplementsRunnable{
　　publicvoidrun(){
　　System.out.println("MyThread.run()");
　　}
}
//为了启动MyThread，需要首先实例化一个Thread，并传入自己的MyThread实例
MyThreadmyThread=newMyThread();
Threadthread=newThread(myThread);
thread.start();

classUtility{//工具类
publicbyte[]getHeadData(String...parms){
        .....
        ....
    }
    publicbyte[]getBodyData(String...parms){
        .....
        ....
    }
    publicbyte[]getFootData(String...parms){
        .....
        ....
    }
}
classSocketClientextendsUtilityimplementsRunnable,Test{//实现Runnable接口
StringhostName;
    intport;
    publicSocketClient(StringhostName,intport){
        this.hostName=hostName;
        this.port=port;
        
    }
//线程启动后的连接，并发送数据的
publicvoidrun(){
try{
InetAddressinetAddress=InetAddress.getByName(hostName);
Socketsocket=newSocket(inetAddress,port);
OutputStreamos=socket.getOutputStream();
BufferedOutputStreambos=newBufferedOutputStream(os);
byte[]sendHeadData=getHeadData("aaa","bbb","ccc");
byte[]sendBodyData=getBodyData("ddd","eee","fff");
byte[]sendFootData=getFootData("ggg","hhh","iii");
bos.write(sendHeadData);
bos.write(sendBodyData);
bos.write(sendFootData);
bos.flush();
}catch(IOExceptione){
//TODOAuto-generatedcatchblock
e.printStackTrace();
}
}
}

//测试的主线程，演示测试的一些场景
publicclassSocketConnectionDemo{

publicintconnectionNumb;//连接数
    
publicStringhostName;//连接的IMSConnect的域名
    
publicintport;//连接的端口
    
publicSocketConnectionDemo(intconnectionNumb,StringhostName,intport){
this.connectionNumb=connectionNumb;
this.hostName=hostName;
this.port=port;
    }
    
publicstaticvoidmain(String[]args){
intconnectionNumb=50;
    StringhostName="ec32181.vmec.svl.com";
    intport=9999;
SocketConnectionDemoscd=newSocketConnectionDemo(connectionNumb,hostName,port);
    
}
    
//最简单的测试场景
    publicvoidtestScenario1(){
        for(inti=1;i<=connectionNumb;i++){
            SocketClientsc=newSocketClient(hostName,port);
            ThreadclientT=newThread(sc,"Client"+i);
            clientT.start();
        }
        //测试的具体逻辑
…..
….
    }
}

classThreadTestimplementsRunnable{
privatestaticCountDownLatchstartCdl;//用于启动所有连接线程的闸门
privatestaticCountDownLatchdoneCdl;//所有连接工作都结束的控制器
    publicThreadTest(CountDownLatchstartCdl,CountDownLatchdoneCdl){
        this.startCdl=startCdl;
        this.doneCdl=doneCdl;
    }
    
    publicvoidrun(){
        try{
startCdl.await();
System.out.println(
Thread.currentThread().getName()+"hasbeenworking!!!!");
            //此处需要代码清单一的那些连接操作
……..
……
…..
            doneCdl.countDown();
        }catch(InterruptedExceptione){
            e.printStackTrace();
        }
    }
}


publicclassCountDownLatchDemo1{
    publicstaticvoidmain(String[]args){
CountDownLatchstartCdl=newCountDownLatch(1);//启动的闸门值为1
CountDownLatchdoneCdl=newCountDownLatch(100);//连接的总数为100
for(inti=1;i<=100;i++){
            ThreadTesttt=newThreadTest(startCdl,doneCdl);
            newThread(tt,"Thread"+i).start();
        }
//记录所有连接线程的开始时间
longstart=System.nanoTime();
//所有线程虽然都已建立，并start。但只有等闸门打开才都开始运行。
startCdl.countDown();
    try{
doneCdl.await();//主线程等待所有连接结束
            //连接达到峰值后，执行一些测试逻辑代码
......
......
......
        }catch(InterruptedExceptione){
//TODOAuto-generatedcatchblock
            e.printStackTrace();
        }
        //记录所有连接线程的结束时间
        longend=System.nanoTime();
        System.out.println("Thetasktakestime(ms):"+(end-start)/100000);
        
    }
}

// 假设建立连接的类是 Connection 
class Connection{ 
     private String connName; 
    
     private String ipAddress; 
    
     public Connection(String connName,String ipAddString) { 
         this.connName=connName; 
         this.ipAddress=ipAddString; 
     } 
     ..... 
     ... 
    
} 

public class ConnectionQueueDemo {

// 使用交换器实现连接器与释放连接器之间资源的共享
private static Exchanger<LinkedList<Connection>> exconn =
new Exchanger<LinkedList<Connection>>();

// 连接器
public class Connector implements Runnable{

private LinkedList<Connection> connQueue;

private String ipAddress;

public Connector(LinkedList<Connection> connQueue,String ipAddress) {
this.connQueue=connQueue;
this.ipAddress=ipAddress;
}
public void run() {
boolean flag=true;
while(flag){
// 每次连接随机的 1~2 个连接。
Random random = new Random();
int connNumb = (random.nextInt())%2 + 1; // 得到随机的 1~2 个连接数

if(connNumb > 1){
System.out.println("Connector creates 2 connection!");
}else{
System.out.println("Connector creates 1 connection!");
}
for(int i=0; i<connNumb; i++){
Connection conn = new Connection("Connector", getIpAddress());
connQueue.add(conn);
}
// 休息 1 秒
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e1) {
e1.printStackTrace();
}
try {
// 交换给释放连接器，让释放连接器工作！
connQueue =(LinkedList<Connection>) exconn.exchange(connQueue);
} catch (InterruptedException e) {
e.printStackTrace();
}
if(connQueue.size()==10){
System.out.println("The connection queue is full!! The programme is end!");
// 当队列满时，可以加入一些测试逻辑代码
....
...
flag=false;
System.exit(0);
}else{
System.out.println("After Disconnector, the size of the queue is "+connQueue.size());
}
}




}

public String getIpAddress(){
return ipAddress;
}
}

// 释放连接器
public class Disconnector implements Runnable {
private LinkedList<Connection> connQueue;
public Disconnector(LinkedList<Connection> connQueue) {
this.connQueue=connQueue;
}
public void run() {
boolean flag=true;
while(flag){
System.out.println("Disconnector disconnects 1 connection!");
if(!connQueue.isEmpty())
connQueue.remove(0);
// 休息 1 秒
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e1) {
e1.printStackTrace();
}
try {
// 交换给连接器，让连接器工作！
connQueue =(LinkedList<Connection>) exconn.exchange(connQueue);
} catch (InterruptedException e) {
e.printStackTrace();
}
if(connQueue.size()==0){
System.out.println("There is no connection in the queue!");
}else{
System.out.println(
"After Connector, the size of the queue is "+connQueue.size());
}
}
}
}
public static void main(String[] args) {
LinkedList<Connection> connQueue = new LinkedList<Connection>();
ConnectionQueueDemo connectionQueueDemo = new ConnectionQueueDemoEx();
new Thread(connectionQueueDemo.new Connector(connQueue,"192.168.1.1")).start();
new Thread(connectionQueueDemo.new Disconnector(connQueue)).start();
}
}