少年阿賓

第一種：（Thread）

package com.abin.lee.servlet.mythread.thread;

public class Mythread extends Thread{
 private String name;
 public Mythread(String name) {
  this.name=name;
 }
 public void run() {
  synchronized(this.name){
   System.out.println("開始時間："+System.currentTimeMillis()+",線程名字："+Thread.currentThread().getName());
   System.out.println("name="+name);
   System.out.println("結束時間："+System.currentTimeMillis()+",線程名字："+Thread.currentThread().getName());
 
  }
 }
 
}

測試代碼：

package com.abin.lee.servlet.mythread.thread;

public class MythreadTest {
 public static void main(String[] args) {
  Mythread mythread1=new Mythread("ManyThread");
  Mythread mythread2=new Mythread("ManyThread");
  mythread1.start();
  mythread2.start();
 }

}

第二種：（Runnable）

package com.abin.lee.servlet.mythread.runnable;

public class MyRunnable implements Runnable{
 private String name;
 public MyRunnable(String name) {
  this.name=name;
 }
 public synchronized void run(){
   System.out.println("開始時間："+System.currentTimeMillis()+",線程名字："+Thread.currentThread().getName());
   System.out.println("name="+name);
   try {
    Thread.sleep(3000);
   } catch (InterruptedException e) {
    e.printStackTrace();
   }
   System.out.println("結束時間："+System.currentTimeMillis()+",線程名字："+Thread.currentThread().getName());
 }
}

測試代碼：

package com.abin.lee.servlet.mythread.runnable;

public class MyRunnableTest {
 public static void main(String[] args) {
  MyRunnable myRunnable=new MyRunnable("ManyThread");
  Thread thread1=new Thread(myRunnable);
  Thread thread2=new Thread(myRunnable);
  thread1.start();
  thread2.start();
 }
}

第三種：（Callable）這種說明一下，這個實現多線程的方式是在JDK1.5引進的，在java.util.concurrent.Callable  這個并發包下面，并且提供同步返回結果的多線程。

package com.abin.lee.servlet.mythread.callable;

import java.util.concurrent.Callable;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class MyCallable implements Callable<String>{
 private String name;
 public MyCallable(String name) {
  this.name=name;
 }
 public String call() throws Exception {
  Lock lock=new ReentrantLock();
  lock.lock();
  String result="";
  try {
   System.out.println("開始時間："+System.currentTimeMillis()+",線程名字："+Thread.currentThread().getName());
   System.out.println("name="+name);
   if(name.equals("ManyThread")){
    result="success";
   }else{
    result="failure";
   }
   try {
    Thread.sleep(3000);
   } catch (InterruptedException e) {
    e.printStackTrace();
   }
   System.out.println("結束時間："+System.currentTimeMillis()+",線程名字："+Thread.currentThread().getName());
 
  } catch (Exception e) {
   e.printStackTrace();
  }finally{
   lock.unlock();
  }
     return result;  
 }
 
}

測試代碼：

package com.abin.lee.servlet.mythread.callable;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

import org.junit.Test;

public class MyCallableTest {
 @Test
 public void testMyCallable() throws InterruptedException, ExecutionException{
  ExecutorService executor=Executors.newFixedThreadPool(3);
  MyCallable myCallable=new MyCallable("ManyThread");
  Future future1=executor.submit(myCallable);
  System.out.println("future1="+future1.get());
  Future future2=executor.submit(myCallable);
  System.out.println("future2="+future2.get());
  Future future3=executor.submit(myCallable);
  System.out.println("future3="+future3.get());
  
 }

}

測試結果：

package com.abin.lee.servlet.important.type;

import java.io.Serializable;

public class LookValue implements Serializable{
 /**
  *
  */
 private static final long serialVersionUID = -7746631577693804188L;
 private int id;
 private String name;
 private transient String status;
 
 public LookValue() {
  super();
 }
 public LookValue(int id, String name, String status) {
  super();
  this.id = id;
  this.name = name;
  this.status = status;
 }
 public int getId() {
  return id;
 }
 public void setId(int id) {
  this.id = id;
 }
 public String getName() {
  return name;
 }
 public void setName(String name) {
  this.name = name;
 }
 public String getStatus() {
  return status;
 }
 public void setStatus(String status) {
  this.status = status;
 }
 
}

package com.abin.lee.servlet.important.type.test;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;

import org.junit.Test;

import com.abin.lee.servlet.important.type.LookValue;
import com.sun.xml.internal.messaging.saaj.util.ByteOutputStream;

public class LookValueTest {
 @Test
 public void testLookValue() throws IOException, ClassNotFoundException{
  LookValue look=new LookValue();
  look.setId(1);
  look.setName("abin");
  look.setStatus("abing");
  OutputStream out=new ByteOutputStream();
  FileOutputStream file=new FileOutputStream("data.ser");
  ObjectOutputStream obj=new ObjectOutputStream(file);
  obj.writeObject(look);
  obj.flush();
  obj.close();
  
  look=null;
  FileInputStream input=new FileInputStream("data.ser");
  ObjectInputStream oin=new ObjectInputStream(input);
  look=(LookValue)oin.readObject();
  oin.close();
  System.out.println("id="+look.getId());
  System.out.println("Name="+look.getName());
  System.out.println("Status="+look.getStatus());
 }
}

輸出結果：
id=1
Name=abin
Status=null

mysql定時器是系統給提供了event，而oracle里面的定時器是系統給提供的job。廢話少說，下面創建表：
create table mytable (
id int auto_increment not null,
name varchar(100) not null default '',
introduce text not null,
createtime timestamp not null,
constraint pk_mytable primary key(id)
)


創建存儲過程，這里的存儲過程主要提供給mysql的定時器event來調用去執行：
create procedure mypro()
BEGIN
insert into mytable (name,introduce,createtime) values ('1111','inner mongolia',now());
end;
這里只是簡單的寫了一下，只是為了說明例子。


緊接著創建mysql的定時器event：
create event if not exists eventJob 
on schedule every 1 second
on completion PRESERVE
do call mypro();
這里設置為每一秒執行一次


至此所有的準備工作已經寫完了，做完這些，mysql要想利用定時器必須的做準備工作，就是把mysql的定時器給開啟了：
SET GLOBAL event_scheduler = 1;  -- 啟動定時器
SET GLOBAL event_scheduler = 0;  -- 停止定時器


緊接著還要開啟事件：
ALTER EVENT eventJob ON  COMPLETION PRESERVE ENABLE;   -- 開啟事件
ALTER EVENT eventJob ON  COMPLETION PRESERVE DISABLE;  -- 關閉事件


SHOW VARIABLES LIKE '%sche%'; -- 查看定時器狀態


至此，你去數據庫里面的表mytable里面看下，系統會每隔一秒去插入一條數據，嘻嘻，任務完成了。
select * from mytable

　在進行性能測試時，一般都需要對應用服務器進行監控，監控的指標包括應用服務器的JVM使用狀況、可用連接數、隊列長度等信息。商業的應用服務器如WebLogic、WebSphere等都提供了Console對這些指標進行監控，在性能測試時可以很容易觀察這些指標的情況。

　　Tomcat作為在國內得到廣泛應用的J2EE服務器，在不少項目中都得到了使用。Tomcat小巧靈活、配置簡單，非常適合小的WEB應用使用。但在對使用Tomcat的應用系統進行性能測試時，最頭疼的問題就是不能獲得應用服務器的相關性能指標數據。

　　其實，從Tomcat 5.0開始，Tomcat就已經為自己提供了一個用于監控應用服務器性能指標的servelet —— status servelet。安裝完Tomcat 5之后，通過訪問 http://yourhost:port/manager/status 就可以獲得當時的應用服務器監控數據。

　　當然，為了安全起見，Tomcat 5在缺省安裝時是不允許用戶直接訪問 http://yourhost:port/manager/status 的，訪問的時候會給出一個403（forbidden）的錯誤信息。在Tomcat的Manual里說明了允許用戶訪問的方法：

   1. 轉到Tomcat的安裝目錄下；
   2. 修改conf/tomcat-users.xml文件，在其中加入一行  <user username="servermon" password="passwd" roles="manager"/>

　　這樣就可以在訪問 http://yourhost:port/manager/status 時給出 servermon 的用戶名與口令，查看到應用服務器的相關性能指標數據。



http://java.chinaitlab.com/server/783798.html 

實現servlet的跳轉，以輸入流的形式來傳輸數據

測試UnionPayServlet的httpClient測試類：
  package com.abin.lee.https;


//被訪問的servlet，也就是中間servlet

以下文章都是整合了好多網上的好多朋友的優秀資源，才寫出來的。具體參考過誰的，我也記不清楚了。關于怎么生成https雙向的證書，地址在這里：
http://www.aygfsteel.com/stevenjohn/archive/2012/08/22/385989.html 
應該正常來說，按照這個教程做的話是沒有任何問題的，但是也有些朋友出過問題，主要問題是在，把證書導入到瀏覽器里面的時候出的，注意這里。

我這里面的我都做過三四次了，基本沒啥問題。但也不排除不會不出問題。

由于網上關于httpCilent來測試調用HTTPS的例子較少，經過在度娘和谷爹的查找，總算是也找到了一篇文章，參考以后，做出來一個測試類，在我機器上面是能夠跑通的。具體地址：http://www.aygfsteel.com/stevenjohn/archive/2012/09/27/388646.html 



//首先說一下，這個是我隨便寫的一個發布到tomcat的httpsUrlConnection的Servlet服務，主要是用來測試一下https雙向驗證的，現在網上好多的文章都是https單向驗證的Java代碼，我在網上看過好多，但是好多都是半成品，然后總結了一下，在自己的機器上面是完全能夠跑通的，在這里做個筆記，以后用得著的時候來拿：

已經發布的準備要測試的https服務：

http://www.cnblogs.com/loveyakamoz/archive/2011/07/21/2113252.html

轉載自：http://www.cnblogs.com/loveyakamoz/archive/2011/07/21/2113251.html

轉載自：http://www.cnblogs.com/loveyakamoz/archive/2011/07/21/2113247.html