少年阿宾

第一种：（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.blogjava.net/stevenjohn/archive/2012/08/22/385989.html 
应该正常来说，按照这个教程做的话是没有任何问题的，但是也有些朋友出过问题，主要问题是在，把证书导入到浏览器里面的时候出的，注意这里。

我这里面的我都做过三四次了，基本没啥问题。但也不排除不会不出问题。

由于网上关于httpCilent来测试调用HTTPS的例子较少，经过在度娘和谷爹的查找，总算是也找到了一篇文章，参考以后，做出来一个测试类，在我机器上面是能够跑通的。具体地址：http://www.blogjava.net/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