#
<input type=file id=meizz style="display: none" onPropertyChange="document.all.ff.value=this.value">
<input name=ff readonly><input type=button value='Browse...' onclick="document.all.meizz.click()">
MySQL的最大连接数默认是100
客户端登录：mysql -uusername -ppassword
设置新的最大连接数为200：mysql> set GLOBAL max_connections=200
显示当前运行的Query：mysql> show processlist
显示当前状态：mysql> show status
退出客户端：mysql> exit
查看当前最大连接数：mysqladmin -uusername -ppassword variables |find "max_con"
http://java.e800.com.cn/articles/2007/417/1176746498587392322_1.html
http://www.oracle.com/technology/tech/java/spring/how-to-jta-spring.html
When your not sure consult the 'Bible', 'Java™ Language Specification'
http://java.sun.com/docs/books/jls/t...ses.html#78119
8.3.1.3 transient Fields
Variables may be marked transient to indicate that they are not part of
the persistent state of an object.
If an instance of the class Point:
class Point {
int x, y;
transient float rho, theta;
}
were saved to persistent storage by a system service, then only the
fields x and y would be saved. This specification does not specify
details of such services; see the specification of java.io.Serializable
for an example of such a service.
8.3.1.4 volatile Fields
As described in §17, the Java programming language allows threads to
access shared variables. As a rule, to ensure that shared variables are
consistently and reliably updated, a thread should ensure that it has
exclusive use of such variables by obtaining a lock that,
conventionally, enforces mutual exclusion for those shared variables.
The Java programming language provides a second mechanism, volatile
fields, that is more convenient than locking for some purposes.
A field may be declared volatile, in which case the Java memory model
(§17) ensures that all threads see a consistent value for the variable.
If, in the following example, one thread repeatedly calls the method one
(but no more than Integer.MAX_VALUE times in all), and another thread
repeatedly calls the method two:
class Test {
static int i = 0, j = 0;
static void one() { i++; j++; }
static void two() {
System.out.println("i=" + i + " j=" + j);
}
}
then method two could occasionally print a value for j that is greater
than the value of i, because the example includes no synchronization
and, under the rules explained in §17, the shared values of i and j
might be updated out of order.
One way to prevent this out-or-order behavior would be to declare
methods one and two to be synchronized (§8.4.3.6):
class Test {
static int i = 0, j = 0;
static synchronized void one() { i++; j++; }
static synchronized void two() {
System.out.println("i=" + i + " j=" + j);
}
}
This prevents method one and method two from being executed
concurrently, and furthermore guarantees that the shared values of i and
j are both updated before method one returns. Therefore method two never
observes a value for j greater than that for i; indeed, it always
observes the same value for i and j.
Another approach would be to declare i and j to be volatile:
class Test {
static volatile int i = 0, j = 0;
static void one() { i++; j++; }
static void two() {
System.out.println("i=" + i + " j=" + j);
}
}
This allows method one and method two to be executed concurrently, but
guarantees that accesses to the shared values for i and j occur exactly
as many times, and in exactly the same order, as they appear to occur
during execution of the program text by each thread. Therefore, the
shared value for j is never greater than that for i, because each update
to i must be reflected in the shared value for i before the update to j
occurs. It is possible, however, that any given invocation of method two
might observe a value for j that is much greater than the value observed
for i, because method one might be executed many times between the
moment when method two fetches the value of i and the moment when method
two fetches the value of j.
See §17 for more discussion and examples.
A compile-time error occurs if a final variable is also declared volatile.
--
Eclipse plug in address
http://propedit.sourceforge.jp/eclipse/
http://www.geniisoft.com/showcase.nsf/WebEditors
1.简述逻辑操作(&,|,^)与条件操作(&&,||)的区别。(15分)
区别主要答两点:
a.条件操作只能操作布尔型的,而逻辑操作不仅可以操作布尔型,而且可以操作数值型
b.逻辑操作不会产生短路.如:
int a = 0;
int b = 0;
if( (a = 3) > 0 || (b = 3) > 0 ) //操后a =3,b=0.
if( (a = 3) > 0 | (b = 3) > 0 ) //操后a =3,b=3.
答对第一点得5分,答对第二点得10分.
本题考察最最基本的知识,但仍然有很多大牛级开发人员下马,任何语言在开始的部分
都会详细介绍这些基本知识,但除了学习第一种语言时,没有人在学习新的语言时愿意
花五分钟来复习一下.
2.下面程序运行会发生什么结果?如果有错误,如何改正? (15分)
interface A{
int x = 0;
}
class B{
int x =1;
}
class C
extends B implements A {
public void pX(){
System.out.println(x);
}
public static void main(String[] args) {
new C().pX();
}
}
}
本题在编译时会发生错误(错误描述不同的JVM有不同的信息,意思就是未明确的x调用,
两个x都匹配,就象在同时import java.util和java.sql两个包时直接声明Date一样)
本题主要考察对接口和类的最最基本的结构的了解.对于父类的变量,可以用super.x来
明确,而接口的属性默认隐含为 public static final.所以可以通过A.x来明确.
3.简述 Java Server Page 和 Servlet 的联系和区别。(20分)
本题不用多说,在答相同点时应该明确知道jsp编译后是"类servlet"而"不是Servlet",
答区别时应该回答出"侧重于(视图/控制逻辑)".其它可根据情况加减分值.知识很简单,
但从面试的角度看,被试者不仅要能知道它们的区别,而且要能比较准确地表达出来(以
后写文档要能让别人看得懂,不产生歧义),回答"jsp编译后就是servlet"视为错误,回答
"jsp用于视图,servlet用于控制逻辑"视为错误,应该用侧重于,主要(多数)用于等词语
表达.
4.XML文档定义有几种形式？它们之间有何本质区别？
解析XML文档有哪几种方式？(20分)
本题三个答题点:
a: 两种形式 dtd,schema
b: 本质区别:schema本身是xml的,可以被XML解析器解析(这也是从DTD上发展schema的
根本目的)
c: 两种主要方式:dom,sax.答出两种得全分,如能答出saxt,或其它(在答出dom,sax的基
础上,如果应试者认为其它方式也可以视为对xml的解析应该允许.但没有答出dom,sax把
其它方式说成是对XML的解析不得分)应该加分.
5.简述synchronized和java.util.concurrent.locks.Lock的异同 ？(15分)
主要相同点:
Lock能完成synchronized所实现的所有功能.(其它不重要)
主要不同点:
Lock有比synchronized更精确的线程语义和更好的性能(在相同点中回答此点也行)
synchronized会自动释放锁.而Lock一定要求程序员手工释放.并且必须在finally从句
中释放,如果没有答出在finally中释放不得分.就如Connection没有在finally中关闭一
样.连最基本的资源释放都做不好,还谈什么多线程编程.
6.EJB规范规定EJB中禁止的操作有哪些？(15分)
共有8点,答出下列3-4点得满分.
1.不能操作线程和线程API(线程API指非线程对象的方法如notify,wait等)
2.不能操作awt
3.不能实现服务器功能
4.不能对静态属生存取.
5.不能使用IO操作直接存取文件系统
6.不能加载本地库.
7.不能将this作为变量和返回.
8.不能循环调用.
7.请问在Java的线程里有个join()函数，这个函数有什么用呀？
是把调用join()的线程连结(join)到当前线程,什么意思呢?就是当前线程等待调用join()线程的结束.比如:当前线程是主线程,它结的时候要求一个被调用的线程a结束,如果我们不调用a.join();那只能轮询a的状态.
while(true){
if(!a.isAlive()) break;
sleep(500);
}
System.exet(1);
如果a线程isAlive,则等500ms继续下一次轮巡,如果已经不可用则结束,这种while(true)的轮询一是占用大量的CPU时间.另一是有可能在sleep(500);时,刚睡1ms时,a就已经!isAlive()了,那就多睡了499ms,浪费了时间,而如果
a.join();
System.exit(1);
则一等a线程结束就会退出.如果没有其它操作,主线程就不会占用CPU时间.
8当一个对象被当作参数传递到一个方法后，此方法可改变这个对象的属性，并可返回变化后的结果，那么这里到底是值传递还是引用传递?
是值传递。Java 编程语言只由值传递参数。当一个对象实例作为一个参数被传递到方法中时，参数的值就是对该对象的引用。对象的内容可以在被调用的方法中改变，但对象的引用是永远不会改变的。
9作用域public,private,protected,以及不写时的区别
答：区别如下：
作用域 当前类 同一package 子孙类 其他package
public √ √ √ √
protected √ √ √ ×
friendly √ √ × ×
private √ × × ×
不写时默认为friendly
10ArrayList和Vector的区别,HashMap和Hashtable的区别
答：就ArrayList与Vector主要从二方面来说.
一.同步性:Vector是线程安全的，也就是说是同步的，而ArrayList是线程序不安全的，不是同步的
二.数据增长:当需要增长时,Vector默认增长为原来一培，而ArrayList却是原来的一半
11一.静态内部类可以有静态成员，而非静态内部类则不能有静态成员。
12静态内部类的非静态成员可以访问外部类的静态变量，而不可访问外部类的非静态变量
13jsp有哪些动作?作用分别是什么?
答:JSP共有以下6种基本动作
jsp:include：在页面被请求的时候引入一个文件。
jsp:useBean：寻找或者实例化一个JavaBean。
jsp:setProperty：设置JavaBean的属性。
jsp:getProperty：输出某个JavaBean的属性。
jsp:forward：把请求转到一个新的页面。
jsp:plugin：根据浏览器类型为Java插件生成OBJECT或EMBED标记
14remote接口和home接口主要作用
remote接口定义了业务方法，用于EJB客户端调用业务方法
home接口是EJB工厂用于创建和移除查找EJB实例
15客服端调用EJB对象的几个基本步骤
一、 设置JNDI服务工厂以及JNDI服务地址系统属性
二、 查找Home接口
三、 从Home接口调用Create方法创建Remote接口
四、 通过Remote接口调用其业务方法
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=gb2312" />
<title>Binny.cn</title>
<script>
var obj=0;
var x=0;
var y=0;
var ie = (navigator.appVersion.indexOf("MSIE")!=-1);//IE
var ff = (navigator.userAgent.indexOf("Firefox")!=-1);//Firefox
function find(evt,objDiv){
obj = objDiv
if (ff){
x = document.documentElement.scrollLeft + evt.layerX;
y = document.documentElement.scrollTop + evt.layerY;
if (document.documentElement.scrollTop > 0){
y = evt.layerY - document.documentElement.scrollTop;
}
if (document.documentElement.scrollLeft > 0){
x = evt.layerX - document.documentElement.scrollLeft;
}
}
if (ie){
x = document.documentElement.scrollLeft + evt.offsetX;
y = document.documentElement.scrollTop + evt.offsetY;
if (document.documentElement.scrollTop > 0){
y = evt.offsetY - document.documentElement.scrollTop;
}
if (document.documentElement.scrollLeft > 0){
x = evt.offsetX - document.documentElement.scrollLeft;
}
}
}
function dragit(evt){
if(obj == 0){
return false
}
else{
obj.style.left = evt.clientX - x + "px";
obj.style.top = evt.clientY - y + "px";
}
}
</script>
</head>
<body style="margin:0" onmousemove="dragit(event)" onmouseup="obj = 0">
<div id="aaa" style="background-color:red;width:200pt;height:200pt;position:absolute">
<div id="aa" style="width:200pt;height:20pt;background:blue;position:absolute" onmousedown="find(event,document.getElementById('aaa'))"></div>
</div><BR><BR><BR><BR><BR><BR><BR><BR><BR><BR><BR><BR><BR><BR><BR><BR><BR><BR><BR><BR><BR><BR><BR><BR><BR><BR><BR><BR><BR><BR><BR><BR><BR>
</body>
</html>
摘自：http://www.binny.cn/article.asp?id=232
/*this can see the table information*/
show table status from `fortioa`;
/*this can see all the fields detail information of a table including the character set*/
show full fields from `account`
/*change the table column`s character set to utf8*/
ALTER TABLE `purchaserequest` CHANGE `justification` `justification` text CHARACTER SET utf8 COLLATE utf8_bin NOT NULL
--执行这个语句,就可以把当前库的所有表的所有者改为dbo
exec sp_msforeachtable 'sp_changeobjectowner ''?'', ''dbo'''