1.下面哪些类可以被继承?
java.lang.Thread (T)
java.lang.Number (T)
java.lang.Double (F)
java.lang.Math (F)
java.lang.Void (F)
java.lang.Class (F)
java.lang.ClassLoader (T)
2.抽象类和接口的区别
(1)接口可以被多重implements,抽象类只能被单一extends
(2)接口只有定义,抽象类可以有定义和实现
(3)接口的字段定义默认为:public static final, 抽象类字段默认是"friendly"(本包可见)
3.Hashtable的原理,并说出HashMap与Hashtable的区别
HashTable的原理:通过节点的关键码确定节点的存储位置,即给定节点的关键码k,通过一定的函数关系H(散列函数),得到函数值H(k),将此值解释为该节点的存储地址.
HashMap 与Hashtable很相似,但HashMap 是非同步(unsynchronizded)和可以以null为关键码的.
4.forward和redirect的区别
forward: an internal transfer in servlet
redirect: 重定向,有2次request,第2次request将丢失第一次的attributs/parameters等
5.什么是Web容器?
实现J2EE规范中web协议的应用.该协议定义了web程序的运行时环境,包括:并发性,安全性,生命周期管理等等.
6.解释下面关于J2EE的名词
(1)JNDI:Java Naming & Directory Interface,JAVA命名目录服务.主要提供的功能是：提供一个目录系统，让其它各地的应用程序在其上面留下自己的索引，从而满足快速查找和定位分布式应用程序的功能.
(2)JMS：Java Message Service,JAVA消息服务.主要实现各个应用程序之间的通讯.包括点对点和广播.
(3)JTA：Java Transaction API,JAVA事务服务.提供各种分布式事务服务.应用程序只需调用其提供的接口即可.
(4)JAF: Java Action FrameWork,JAVA安全认证框架.提供一些安全控制方面的框架.让开发者通过各种部署和自定义实现自己的个性安全控制策略.
8.XML的解析方法
Sax,DOM,JDOM
9.什么是Web Service?
Web Service就是为了使原来各孤立的站点之间的信息能够相互通信、共享而提出的一种接口。
Web Service所使用的是Internet上统一、开放的标准，如HTTP、XML、SOAP（简单对象访问协议）、WSDL等，所以Web Service可以在任何支持这些标准的环境（Windows,Linux）中使用。
注：SOAP协议（Simple Object Access Protocal,简单对象访问协议）,它是一个用于分散和分布式环境下网络信息交换的基于XML的通讯协议。在此协议下，软件组件或应用程序能够通过标准的HTTP协议进行通讯。它的设计目标就是简单性和扩展性，这有助于大量异构程序和平台之间的互操作性，从而使存在的应用程序能够被广泛的用户访问。
优势：
(1).跨平台。
(2).SOAP协议是基于XML和HTTP这些业界的标准的，得到了所有的重要公司的支持。
(3).由于使用了SOAP，数据是以ASCII文本的方式而非二进制传输，调试很方便；并且由于这样，它的数据容易通过防火墙，不需要防火墙为了程序而单独开一个“漏洞”。
(4).此外，WebService实现的技术难度要比CORBA和DCOM小得多。
(5).要实现B2B集成，EDI比较完善与比较复杂；而用WebService则可以低成本的实现，小公司也可以用上。
(6).在C/S的程序中，WebService可以实现网页无整体刷新的与服务器打交道并取数。
缺点：
(1).WebService使用了XML对数据封装，会造成大量的数据要在网络中传输。
(2).WebService规范没有规定任何与实现相关的细节，包括对象模型、编程语言，这一点，它不如CORBA。
缺点：
(1).WebService使用了XML对数据封装，会造成大量的数据要在网络中传输。
(2).WebService规范没有规定任何与实现相关的细节，包括对象模型、编程语言，这一点，它不如CORBA。
10.多线程有几种实现方法,都是什么?同步有几种实现方法,都是什么?
答：多线程有两种实现方法，分别是继承Thread类与实现Runnable接口
同步的实现方面有两种，分别是synchronized,wait与notify
11.JSP中动态INCLUDE与静态INCLUDE的区别？
动态INCLUDE用jsp:include动作实现
<jsp:include page="included.jsp" flush="true"/>
它总是会检查所含文件中的变化，适合用于包含动态页面，并且可以带参数
静态INCLUDE用include伪码实现,不会检查所含文件的变化，适用于包含静态页面
<%@ include file="included.htm" %>
三、数据库
1.删除表的重复记录
如果记录完全相同才算重复记录,那么: (sql server2000下测试通过)
select distinct * into #tmpp from tid
delete from tid
insert into tid select * from #tmpp
drop table #tmpp
如果有id主键(数字,自增1的那种),那么:(sql server2000下测试通过)
delete from tableA where id not in
(select id = min(id) from tableA group by name)
2.delete from tablea & truncate table tablea的区别
truncate 语句执行速度快,占资源少,并且只记录页删除的日志；
delete 对每条记录的删除均需要记录日志
详情请参考：【Software Myzone】：http://www.firedragonpzy.com.cn/index.php/archives/1409
一般一个简单线程池至少包含下列组成部分
- 线程池管理器（ThreadPoolManager）:用于创建并管理线程池
- 工作线程（WorkThread）: 线程池中线程
- 任务接口（Task）:每个任务必须实现的接口，以供工作线程调度任务的执行。
- 任务队列:用于存放没有处理的任务。提供一种缓冲机制。
package com.yulin.threadpool;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedList;
/*
* 线程池管理器（PoolManager）:用于创建并管理线程池，采用单例模式
*
*/
public class PoolManage {
public static PoolManage mPool=new PoolManage();
public final int max_pool =2;
public final int max_Tasks = 15;
public static ArrayList<Worker> init_pools;
private int GetIdleThreadPollTime=50;//获取空闲线程轮询间隔时间,可配置
private TaskMonitorThread mainThread;//任务监测线程
static {
init_pools = new ArrayList(1);
}
public static PoolManage getInstance() {
if (mPool == null) {
mPool = new PoolManage();
}
return mPool;
}
//获取空闲线程
public Worker getIdleThread(){
Worker working =null;
while(true){
synchronized(init_pools){
for (int i = 0; i < max_pool; i++) {
//Worker working = init_pools.get(i);
working = init_pools.get(i);
if (!working.isrunning) {
// System.out.println("工作将由闲置线程" + working.getThreadTag() + "执行");
return working;
}
}
}
try {
Thread.sleep(5000);//放弃CPU,若干时间后重新获取空闲线程
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
public void init() {
System.out.println("线程池初始化开始。。。");
Worker worker = null;
for (int i = 0; i < this.max_pool; i++) {
worker = new Worker("initThread"+i);
init_pools.add(worker);
worker.start();
}
mainThread=new TaskMonitorThread();
mainThread.start();
System.out.println("结束初始化线程池...");
}
}
package com.yulin.threadpool;
import java.util.LinkedList;
/**
* 任务管理器
* 1、添加任务
* 2、监测是否有新任务
*/
public class TaskManager {
public static LinkedList<WorkTask> workqueue =new LinkedList<WorkTask>();// 缓冲队列
/**
* 向工作队列中加入一个任务，由工作线程去执行该任务
*
* @param task
*/
public synchronized static void addTask(WorkTask worktask) {
if (worktask != null &&workqueue.size()<15) {
workqueue.add(worktask);
}
}
/*[com.yulin.threadpool.WorkTaskImp@44f4ac30,
com.yulin.threadpool.WorkTaskImp@44f4ad60,
com.yulin.threadpool.WorkTaskImp@44f4ae00,
com.yulin.threadpool.WorkTaskImp@44f4aea0,
com.yulin.threadpool.WorkTaskImp@44f4af40]*/
/**
* 从工作队列中取出一个任务
*
* @return
* @throws InterruptedException
*/
public synchronized static WorkTask getTask() throws InterruptedException {
while (workqueue.size() >0) {
return (WorkTask) workqueue.removeFirst();
}
return null;
}
}
package com.yulin.threadpool;
/**
* 任务检测线程类 检测空闲线程并检测待运行任务
*/
public final class TaskMonitorThread extends Thread {
//private PoolManage threadPool;
private int GetWorkTaskPollTime = 10;// 监测任务轮询时间，可配置
/*public TaskMonitorThread(PoolManage pool) {
System.out.println("正在创建任务监测线程...");
this.threadPool = pool;
}*/
public TaskMonitorThread() {
System.out.println("正在创建任务监测线程...");
}
@Override
public void run() {
// TODO Auto-generated method stub
while (true) {
try {
WorkTask task = TaskManager.getTask();
if (task == null) {
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
} else {
Worker t = PoolManage.getInstance().getIdleThread();// 获取空闲线程
System.out.println("Worker.toString()=============================>?"+t.toString());
if (t == null)
break;
t.setWorkTask(task);// 设置线程任务
System.out.println("task.toString()=============================>?"+task.toString());
t.setIsRunning(true);//激活空闲线程
System.out.println("Worker.toString()=============================>?"+t.getIsrunning());
// try {
//Thread.sleep(GetWorkTaskPollTime);
//
}
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
package com.yulin.threadpool;
/**
* 工作线程（WorkThread）: 线程池中线程
* @author yulin
*
*/
public class Worker extends Thread {
public boolean isrunning=false;
private WorkTask nowTask; // 当前任务
private Object threadTag;// 线程标识
//获取线程标识key
public Object getThreadTag() {
return threadTag;
}
public synchronized void setWorkTask(WorkTask task) {
this.nowTask = task;
}
public synchronized void setIsRunning(boolean flag) {
this.isrunning = flag;
if (flag) {
this.notify();
}
}
public Worker(Object key) {
System.out.println("正在创建工作线程...线程编号" + key.toString());
this.threadTag = key;
// this.state=CREATESTATE;
}
public boolean getIsrunning() {
return isrunning;
}
public synchronized void run() {
System.out.println("工作线程" + this.getThreadTag() + "初始化成功");
while (true) {
if (!isrunning) {
try {
System.out.println("工人" + this.getThreadTag() + "任务完成回归线程池");
this.wait();
} catch (InterruptedException e) {
System.out.println("线程被阻挡");
e.printStackTrace();
}
} else {
//try {
nowTask.runTask();
setIsRunning(false);
System.out.println("工人" +this.getThreadTag() + "开始工作");
//this.sleep(3000);
//} catch (InterruptedException e) {
// e.printStackTrace();
//}
//this.notify();
//break;
}
}
}
}
package com.yulin.threadpool;
/**
* 任务接口
* 继承它来定义自己具体的工作任务
*/
public interface WorkTask {
public void runTask();//执行工作任务
//public int compareTo(mJob job);
public void cancelTask();
public int getProgress();
}
package com.yulin.threadpool;
import android.util.Log;
/**
* 任务类1
* 正常执行的工作任务
*/
public class WorkTaskAImp implements WorkTask {
protected String param;
public WorkTaskAImp(){
}
public WorkTaskAImp(String param){
this.param=param;
}
@Override
public void runTask() {
// TODO Auto-generated method stub
// Log.v("=============>Task1", this.param);
System.out.println("=============>Task1"+this.param);
}
@Override
public void cancelTask() {
// TODO Auto-generated method stub
}
@Override
public int getProgress() {
// TODO Auto-generated method stub
return 0;
}
}
package com.yulin.threadpool;
import android.util.Log;
/**
* 任务类1
* 正常执行的工作任务
*/
public class WorkTaskImp implements WorkTask {
protected String param;
public WorkTaskImp(){
}
public WorkTaskImp(String param){
this.param=param;
}
@Override
public void runTask() {
// TODO Auto-generated method stub
System.out.println("=============>Task0"+this.param);
}
@Override
public void cancelTask() {
// TODO Auto-generated method stub
}
@Override
public int getProgress() {
// TODO Auto-generated method stub
return 0;
}
}
最后是测试 类
package com.example.test;
import com.example.task.TaskManager;
import com.example.task.WorkTask;
import com.example.task.WorkTaskAImp;
import com.example.task.WorkTaskBImp;
import com.example.task.WorkTaskImp;
import com.example.thread.ThreadPool;
/**
* 线程池测试类,测试功能如下：
* 1、测试线程池创建功能
* 2、测试处理并发请求功能
* 3、测试关闭功能
**/
public class TestThreadPool {
public static void main(String[] args){
//创建线程池,开启处理请求服务
final int threadCount=10;
ThreadPool pool=ThreadPool.getInstance();
pool.init(threadCount);
//接收客户端请求
WorkTask task1=new WorkTaskAImp("执行超时任务1...");
TaskManager.addTask(task1);
final int requestCount=15;
for(int i=0;i<requestCount;i++){
WorkTask task=new WorkTaskImp("执行第"+i+"个增加用户操作.....");
TaskManager.addTask(task);
}
/**/
}
}