總結(jié)不僅僅是總結(jié)成績，更重要的是為了研究經(jīng)驗，發(fā)現(xiàn)做好工作的規(guī)律，也可以找出工作失誤的教訓(xùn)。這些經(jīng)驗教訓(xùn)是非常寶貴的，對工作有很好的借鑒與指導(dǎo)作用，在今后工作中可以改進提高，趨利避害，避免失誤。寫總結(jié)的時候需要注意什么呢？有哪些格式需要注意呢？下面是小編為大家?guī)淼目偨Y(jié)書優(yōu)秀范文，希望大家可以喜歡。
java線程知識點總結(jié) java線程寫法篇一
計算器
班級：****** 姓名：******
學(xué)號： ******* 指導(dǎo)老師：******
實驗名稱:java計算器
1實驗?zāi)康? java編程語言在編程方面的具體應(yīng)用,以及使用面向?qū)ο蠓椒?對小應(yīng)用程序進行需求分
析、概要設(shè)計、詳細設(shè)計，最后使用java編程實現(xiàn)的全過程。
2實驗意義：
在編程我們使用的java語言，是目前比較流行的編程語言。在當(dāng)今這個時代，java語言在編程方面的優(yōu)勢使得編程有了更好的選擇。java語言最大的特點是具有跨平臺性，使其不受平臺不同的影響，得到了廣泛的應(yīng)用。實訓(xùn)性質(zhì)
本課程是計算機信息管理專業(yè)的一門實踐性課程，是《java編程》課程的實踐性教學(xué)環(huán)節(jié)。實訓(xùn)目標(biāo)
⑴綜合應(yīng)用java程序設(shè)計的知識解決實際問題。
⑵學(xué)會在應(yīng)用程序的設(shè)計過程中，應(yīng)用面向?qū)ο蟮某绦蛟O(shè)計方法。⑶學(xué)會應(yīng)用jdbc創(chuàng)建數(shù)據(jù)庫應(yīng)用程序。
⑷學(xué)會開發(fā)基于swing的應(yīng)用程序及多文檔應(yīng)用程序的設(shè)計。實訓(xùn)任務(wù)
用java語言開發(fā)工具（例如jdk、jcreator、netbeans等）制作一個簡單的可運行的完整的應(yīng)用程序或小型系統(tǒng)，并編制出各階段必要的文檔。
將創(chuàng)建一個計算器，可以進行常用的加減乘除算術(shù)運算。本實例的知識點有：窗口布局器gridlayout的應(yīng)用，對按鈕消息的監(jiān)聽和響應(yīng)。
6實訓(xùn)條件
<軟件:>windows xp,netbeans ide 6.52 7開發(fā)背景: java是由sun microsystems公司于1995年5月推出的java程序設(shè)計語言（以下簡稱java語言）和java平臺的總稱。java語言是一個支持網(wǎng)絡(luò)計算的面向?qū)ο蟪绦蛟O(shè)計語言。java語言吸收了smalltalk語言和c++語言的優(yōu)點，并增加了其它特性，如支持并發(fā)程序設(shè)計、網(wǎng)絡(luò)通信、和多媒體數(shù)據(jù)控制等。
8系統(tǒng)部分分析:
1)java語言是簡單的。java語言的語法與c語言和c++語言很接近，使得大多數(shù)程序員很容易學(xué)習(xí)和使用java。另一方面，java丟棄了c++ 中很少使用的、很難理解的、令人迷惑的那些特性，如操作符重載、多繼承、自動的強制類型轉(zhuǎn)換。
2)java語言是一個面向?qū)ο蟮?。java語言提供類、接口和繼承等原語，為了簡單起見，只支持類之間的單繼承，但支持接口之間的多繼承，并支持類與接口之間的實現(xiàn)機制（關(guān)鍵字為implements）。java語言全面支持動態(tài)綁定，而c++ 語言只對虛函數(shù)使用動態(tài)綁定
3)java語言是分布式的。java語言支持internet應(yīng)用的開發(fā)，在基本的java應(yīng)用編程接口中有一個網(wǎng)絡(luò)應(yīng)用編程接口（），它提供了用于網(wǎng)絡(luò)應(yīng)用編程的類庫，包括url、urlconnection、socket、serversocket等。java的rmi(遠程方法激活)機制也是開發(fā)分布式應(yīng)用的重要手段。
4)java語言是健壯的。java的強類型機制、異常處理、廢料的自動收集等是java程序健壯性的重要保證。對指針的丟棄是java的明智選擇。java的安全檢查機制使得java更具健壯性。
5)java語言是安全的。java通常被用在網(wǎng)絡(luò)環(huán)境中，為此，java提供了一個安全機制以防惡意代碼的攻擊。除了java語言具有的許多安全特性以外，java對通過網(wǎng)絡(luò)下載的類具有一個安全防范機制（類classloader），如分配不同的名字空間以防替代本地的同名類、字節(jié)代碼檢查，并提供安全管理機制.6)java語言是體系結(jié)構(gòu)中立的。java程序（后綴為java的文件）在java平臺上被編譯為體系結(jié)構(gòu)中立的字節(jié)碼格式（后綴為class的文件）, 然后可以在實現(xiàn)這個java平臺的任何系統(tǒng)中運行。
7)java語言是可移植的。這種可移植性來源于體系結(jié)構(gòu)中立性，另外，java還嚴格規(guī)定了各個基本數(shù)據(jù)類型的長度。java系統(tǒng)本身也具有很強的可移植性，java編譯器是用java實現(xiàn)的.8)java語言是解釋型的。如前所述，java程序在java平臺上被編譯為字節(jié)碼格式，然后可以在實現(xiàn)這個java平臺的任何系統(tǒng)中運行。
9)java是高性能的。與那些解釋型的高級腳本語言相比，java的確是高性能的。事實上，java的運行速度隨著jit(just-in-time)編譯器技術(shù)的發(fā)展越來越接近于c++。
10)java語言是多線程的。在java語言中，線程是一種特殊的對象，它必須由thread類或其子（孫）類來創(chuàng)建。
11)java語言是動態(tài)的。java語言的設(shè)計目標(biāo)之一是適應(yīng)于動態(tài)變化的環(huán)境。
目錄
課程設(shè)計題目 ……………………………… p1
課程設(shè)計簡介 ……………………………… p2
課程設(shè)計源代碼…………………………… p5
課程設(shè)計運行結(jié)果 ……………………… p15 課程設(shè)計心得體會 ………………………
p16
package computerpad;import .*;import .event.*;import .*;import .*;import list;import format;public class computerpad extends frame implements actionlistener {
numberbutton numberbutton[];
operationbutton oprationbutton[];
button 小數(shù)點按鈕,正負號按鈕,退格按鈕，求倒數(shù)按鈕,等號按鈕,清零按鈕;
panel panel;
jtextfield resultshow;
string 運算符號[]={“+”,“-”,“*”,“/”};
linkedlist 鏈表;
boolean 是否按下等號=false;
public computerpad()
{
super(“計算器”);
鏈表=new linkedlist();
numberbutton=new numberbutton[10];
for(int i=0;i<=9;i++)
{
numberbutton[i]=new numberbutton(i);
numberbutton[i].addactionlistener(this);
}
oprationbutton=new operationbutton[4];
for(int i=0;i<4;i++)
{
oprationbutton[i]=new operationbutton(運算符號[i]);
oprationbutton[i].addactionlistener(this);
}
小數(shù)點按鈕=new button(“.”);
正負號按鈕
=new button(“+/-”);
等號按鈕=new button(“=”);
求倒數(shù)按鈕=new button(“1/x”);
退格按鈕=new button(“退格”);
清零按鈕=new button(“c”);
eground();
eground();
eground();
eground();
eground();
eground();
ionlistener(this);
ionlistener(this);
ionlistener(this);
ionlistener(this);
ionlistener(this);
ionlistener(this);
resultshow=new jtextfield(10);
izontalalignment();
eground();
t(new font(“timesroman”,,14));
der(new softbevelborder(d));
kground();
table(false);
panel=new panel();
out(new gridlayout(4,5));
(numberbutton[1]);
(numberbutton[2]);
(numberbutton[3]);
(oprationbutton[0]);
(清零按鈕);
(numberbutton[4]);
(numberbutton[5]);
(numberbutton[6]);
(oprationbutton[1]);
(退格按鈕);
(numberbutton[7]);
(numberbutton[8]);
(numberbutton[9]);
(oprationbutton[2]);
(求倒數(shù)按鈕);
(numberbutton[0]);
(正負號按鈕);
(小數(shù)點按鈕);
(oprationbutton[3]);
(等號按鈕);
add(panel,);
add(resultshow,);
addwindowlistener(new windowadapter()
{ public void windowclosing(windowevent e)
{
(0);
}
});
setvisible(true);
setbounds(100,50,240,180);
setresizable(false);
validate();
} public void actionperformed(actionevent e)
{
if(rce()instanceof numberbutton)
{
numberbutton b=(numberbutton)rce();
if(()==0)
{
int number=ber();
(“"+number);
t(”“+number);
是否按下等號=false;
}
else if(()==1&&是否按下等號==false)
{
int number=ber();
string num=(string)first();
string s=(”“+number);
(0,s);
t(s);
}
else if(()==1&&是否按下等號==true)
{
int number=ber();
first();
(”“+number);
是否按下等號=false;
t(”“+number);
}
else if(()==2)
{
int number=ber();
(”“+number);
t(”“+number);
}
else if(()==3)
{
int number=ber();
string num=(string)t();
string s=(”“+number);
(2,s);
t(s);
}
}
else if(rce()instanceof operationbutton)
{
operationbutton b=(operationbutton)rce();
if(()==1)
{
string fuhao=運算符號();
(fuhao);
}
else if(()==2)
{
string fuhao=運算符號();
(1,fuhao);
}
else if(()==3)
{
string fuhao=運算符號();
string number1=(string)first();
string number2=(string)t();
string 運算符號=(string)(1);
try
{
double n1=ouble(number1);
double n2=ouble(number2);
double n=0;
if((”+“))
{
n=n1+n2;
}
else if((”-“))
{
n=n1-n2;
}
else if((”*“))
{
n=n1*n2;
}
else if((”/“))
{
n=n1/n2;
}
();
(”“+n);
(fuhao);
t(”“+n);
}
catch(exception ee)
{
}
}
}
else if(rce()==等號按鈕)
{
是否按下等號=true;
if(()==1||()==2)
{
string num=(string)first();
t(”“+num);
}
else if(()==3)
{
string number1=(string)first();
string number2=(string)t();
string 運算符號=(string)(1);
try
{
double n1=ouble(number1);
double n2=ouble(number2);
double n=0;
if((”+“))
{
n=n1+n2;
}
else if((”-“))
{
n=n1-n2;
}
else if((”*“))
{
n=n1*n2;
}
else if((”/“))
{
n=n1/n2;
}
t(”“+n);
(0,”“+n);
last();
last();
}
catch(exception ee)
{
}
}
}
else if(rce()==小數(shù)點按鈕)
{
if(()==0)
{
是否按下等號=false;
}
else if(()==1)
{
string dot=el();
string num=(string)first();
string s=null;
if(f(dot)==-1)
{
s=(dot);
(0,s);
}
else
{
s=num;
}
(0,s);
t(s);
}
else if(()==3)
{
string dot=el();
string num=(string)t();
string s=null;
if(f(dot)==-1)
{
s=(dot);
(2,s);
}
else
{
s=num;
}
t(s);
}
}
else if(rce()==退格按鈕)
{
if(()==1)
{
string num=(string)first();
if(()>=1)
{
num=ing(0,()-1);
(0,num);
t(num);
}
else
{
last();
t(”0“);
}
}
else if(()==3)
{
string num=(string)t();
if(()>=1)
{ num=ing(0,()-1);
(2,num);
t(num);
}
else
{
last();
t(”0“);
}
}
}
else if(rce()==正負號按鈕)
{
if(()==1)
{
string number1=(string)first();
try
{
double d=ouble(number1);
d=-1*d;
string str=f(d);
(0,str);
t(str);
}
catch(exception ee)
{
}
}
else if(()==3)
{
string number2=(string)t();
try
{
double d=ouble(number2);
d=-1*d;
string str=f(d);
(2,str);
t(str);
}
catch(exception ee){
}
}
}
else if(rce()==求倒數(shù)按鈕)
{
if(()==1||()==2)
{
string number1=(string)first();
try
{
double d=ouble(number1);
d=1.0/d;
string str=f(d);
(0,str);
t(str);
}
catch(exception ee){
}
}
else if(()==3)
{
string number2=(string)t();
try
{
double d=ouble(number2);
d=1.0/d;
string str=f(d);
(0,str);
t(str);
}
catch(exception ee){
}
}
}
else if(rce()==清零按鈕)
{
是否按下等號=false;
t(”0“);
();
}
} public static void main(string args[])
{
new computerpad();
}
}
package computerpad;import .*;import .event.*;import .*;public class numberbutton extends button {
int number;
public numberbutton(int number)
{
super(”"+number);
=number;
setforeground();
}
public int getnumber()
{
return number;
} }
import .*;import .event.*;import .*;public class operationbutton extends button {
string 運算符號;
public operationbutton(string s)
{
super(s);
運算符號=s;
setforeground();
}
public string get運算符號()
{
return 運算符號;
} } 14 java實訓(xùn)心得：
未接觸java之前，聽人說java這門語言如何的強大和難以入門，但學(xué)習(xí)之后，給我的感覺卻是語言沒有所謂的難于不難，關(guān)鍵是自己有沒有真正投入去學(xué)，有沒有花時間去學(xué)。java是一門很好的語言，經(jīng)過周圍人對java的宣傳，我一開始不敢去學(xué)習(xí)這門語言，因為一門高級語言總是讓人想到一開始的學(xué)習(xí)會很難，但是后來在自己的努力和老師同學(xué)的幫助下，我加入了java學(xué)習(xí)者的行列。
老師把我們帶進了門，那么，以后漫長的深入學(xué)習(xí)還是要靠自己。經(jīng)常性的編寫一些程序，或則去看懂、研究透別人編寫的程序?qū)τ谖覀兇蚝没A(chǔ)是非常有利的。讓我們懷著對java的一腔熱情，用自己的刻苦努力去把java學(xué)好。將來，用自己的成績?nèi)セ貓笥卸饔谖覀兊纳鐣⒓胰撕团笥选?/p>
java線程知識點總結(jié) java線程寫法篇二
線程編程方面
60、java中有幾種方法可以實現(xiàn)一個線程？用什么關(guān)鍵字修飾同步方法? stop()和suspend()方法為何不推薦使用？
答：有兩種實現(xiàn)方法，分別是繼承thread類與實現(xiàn)runnable接口 用synchronized關(guān)鍵字修飾同步方法
反對使用stop()，是因為它不安全。它會解除由線程獲取的所有鎖定，而且如果對象處于一種不連貫狀態(tài)，那么其他線程能在那種狀態(tài)下檢查和修改它們。結(jié)果很難檢查出真正的問題所在。suspend()方法容易發(fā)生死鎖。調(diào)用suspend()的時候，目標(biāo)線程會停下來，但卻仍然持有在這之前獲得的鎖定。此時，其他任何線程都不能訪問鎖定的資源，除非被“掛起”的線程恢復(fù)運行。對任何線程來說，如果它們想恢復(fù)目標(biāo)線程，同時又試圖使用任何一個鎖定的資源，就會造成死鎖。所以不應(yīng)該使用suspend()，而應(yīng)在自己的thread類中置入一個標(biāo)志，指出線程應(yīng)該活動還是掛起。若標(biāo)志指出線程應(yīng)該掛起，便用wait()命其進入等待狀態(tài)。若標(biāo)志指出線程應(yīng)當(dāng)恢復(fù)，則用一個notify()重新啟動線程。61、sleep()和 wait()有什么區(qū)別? 答：sleep是線程類（thread）的方法，導(dǎo)致此線程暫停執(zhí)行指定時間，給執(zhí)行機會給其他線程，但是監(jiān)控狀態(tài)依然保持，到時后會自動恢復(fù)。調(diào)用sleep不會釋放對象鎖。
wait是object類的方法，對此對象調(diào)用wait方法導(dǎo)致本線程放棄對象鎖，進入等待此對象的等待鎖定池，只有針對此對象發(fā)出notify方法（或notifyall）后本線程才進入對象鎖定池準備獲得對象鎖進入運行狀態(tài)。
62、同步和異步有何異同，在什么情況下分別使用他們？舉例說明。
答：如果數(shù)據(jù)將在線程間共享。例如正在寫的數(shù)據(jù)以后可能被另一個線程讀到，或者正在讀的數(shù)據(jù)可能已經(jīng)被另一個線程寫過了，那么這些數(shù)據(jù)就是共享數(shù)據(jù)，必須進行同步存取。
當(dāng)應(yīng)用程序在對象上調(diào)用了一個需要花費很長時間來執(zhí)行的方法，并且不希望讓程序等待方法的返回時，就應(yīng)該使用異步編程，在很多情況下采用異步途徑往往更有效率。63、啟動一個線程是用run()還是start()? 答：啟動一個線程是調(diào)用start()方法，使線程所代表的虛擬處理機處于可運行狀態(tài)，這意味著它可以由jvm調(diào)度并執(zhí)行。這并不意味著線程就會立即運行。run()方法可以產(chǎn)生必須退出的標(biāo)志來停止一個線程。
64、當(dāng)一個線程進入一個對象的一個synchronized方法后，其它線程是否可進入此對象的其它方法? 答：不能，一個對象的一個synchronized方法只能由一個線程訪問。
我認為：其他線程可以進入非synchronized方法，但不能進入這個對象的synchronized方法。65、請說出你所知道的線程同步的方法。
答：wait():使一個線程處于等待狀態(tài)，并且釋放所持有的對象的lock。
sleep():使一個正在運行的線程處于睡眠狀態(tài)，是一個靜態(tài)方法，調(diào)用此方法要捕捉interruptedexception異常。
notify():喚醒一個處于等待狀態(tài)的線程，注意的是在調(diào)用此方法的時候，并不能確切的喚醒某一個等待狀態(tài)的線程，而是由jvm確定喚醒哪個線程，而且不是按優(yōu)先級。
allnotity():喚醒所有處入等待狀態(tài)的線程，注意并不是給所有喚醒線程一個對象的鎖，而是讓它們競爭。
66、多線程有幾種實現(xiàn)方法,都是什么?同步有幾種實現(xiàn)方法,都是什么? 答：多線程有兩種實現(xiàn)方法，分別是繼承thread類與實現(xiàn)runnable接口 同步的實現(xiàn)方面有兩種，分別是synchronized,wait與notify 67、線程的基本概念、線程的基本狀態(tài)以及狀態(tài)之間的關(guān)系
答：線程指在程序執(zhí)行過程中，能夠執(zhí)行程序代碼的一個執(zhí)行單位，每個程序至少都有一個線程，也就是程序本身。
java中的線程有四種狀態(tài)分別是：運行、就緒、掛起、結(jié)束
68、的異同 ？ 答：主要相同點：lock能完成synchronized所實現(xiàn)的所有功能
主要不同點：lock有比synchronized更精確的線程語義和更好的性能。synchronized會自動釋放鎖，而lock一定要求程序員手工釋放，并且必須在finally從句中釋放。
jsp方面
69、forward 和redirect的區(qū)別
答：forward是服務(wù)器請求資源，服務(wù)器直接訪問目標(biāo)地址的url，把那個url的響應(yīng)內(nèi)容讀取過來，然后把這些內(nèi)容再發(fā)給瀏覽器，瀏覽器根本不知道服務(wù)器發(fā)送的內(nèi)容是從哪兒來的，所以它的地址欄中還是原來的地址。
redirect就是服務(wù)端根據(jù)邏輯,發(fā)送一個狀態(tài)碼,告訴瀏覽器重新去請求那個地址，一般來說瀏覽器會用剛才請求的所有參數(shù)重新請求，所以session,request參數(shù)都可以獲取。70、jsp有哪些內(nèi)置對象?作用分別是什么?
答：jsp共有以下9種基本內(nèi)置組件（可與asp的6種內(nèi)部組件相對應(yīng)）：
request 用戶端請求，此請求會包含來自get/post請求的參數(shù)
response 網(wǎng)頁傳回用戶端的回應(yīng)
pagecontext 網(wǎng)頁的屬性是在這里管理
session 與請求有關(guān)的會話期
application servlet 正在執(zhí)行的內(nèi)容
out 用來傳送回應(yīng)的輸出 config servlet的構(gòu)架部件
page jsp網(wǎng)頁本身
exception 針對錯誤網(wǎng)頁，未捕捉的例外
71、jsp有哪些動作?作用分別是什么? 答:jsp共有以下6種基本動作
jsp:include：在頁面被請求的時候引入一個文件。
jsp:usebean：尋找或者實例化一個javabean。
jsp:setproperty：設(shè)置javabean的屬性。
jsp:getproperty：輸出某個javabean的屬性。
jsp:forward：把請求轉(zhuǎn)到一個新的頁面。
jsp:plugin：根據(jù)瀏覽器類型為java插件生成object或embed標(biāo)記 72、jsp中動態(tài)include與靜態(tài)include的區(qū)別？
答：動態(tài)include用jsp:include動作實現(xiàn)
它總是會檢查所含文件中的變化，適合用于包含動態(tài)頁面，并且可以帶參數(shù)靜態(tài)include用include偽碼實現(xiàn),定不會檢查所含文件的變化，適用于包含靜態(tài)頁面
<%@ include file=“” %> 73、兩種跳轉(zhuǎn)方式分別是什么?有什么區(qū)別? 答：有兩種，分別為：
前者頁面不會轉(zhuǎn)向include所指的頁面，只是顯示該頁的結(jié)果，主頁面還是原來的頁面。執(zhí)行完后還會回來，相當(dāng)于函數(shù)調(diào)用。并且可以帶參數(shù).后者完全轉(zhuǎn)向新頁面，不會再回來。相當(dāng)于go to 語句。
74、jsp的內(nèi)置對象及方法。答：request表示httpservletrequest對象。它包含了有關(guān)瀏覽器請求的信息，并且提供了幾個用于獲取cookie, header, 和session數(shù)據(jù)的有用的方法。
response表示httpservletresponse對象，并提供了幾個用于設(shè)置送回 瀏覽器的響應(yīng)的方法（如cookies,頭信息等）
ter的一個實例，并提供了幾個方法使你能用于向瀏覽器回送輸出結(jié)果。
ntext對象。它是用于方便存取各種范圍的名字空間、servlet相關(guān)的對象的api，并且包裝了通用的servlet相關(guān)功能的方法。
ssion對象。session可以存貯用戶的狀態(tài)信息
applicaton tcontext對象。這有助于查找有關(guān)servlet引擎和servlet環(huán)境的信息
tconfig對象。該對象用于存取servlet實例的初始化參數(shù)。page表示從該頁面產(chǎn)生的一個servlet實例
servlet方面
75、說一說servlet的生命周期?
答:servlet有良好的生存期的定義，包括加載和實例化、初始化、處理請求以及服務(wù)結(jié)束。t接口的init,service和destroy方法表達。servlet被服務(wù)器實例化后，容器運行其init方法，請求到達時運行其service方法，service方法自動派遣運行與請求對應(yīng)的doxxx方法（doget，dopost）等，當(dāng)服務(wù)器決定將實例銷毀的時候調(diào)用其destroy方法。
與cgi的區(qū)別在于servlet處于服務(wù)器進程中，它通過多線程方式運行其service方法，一個實例可以服務(wù)于多個請求，并且其實例一般不會銷毀，而cgi對每個請求都產(chǎn)生新的進程，服務(wù)完成后就銷毀，所以效率上低于servlet。
76、java servlet api中forward()與redirect()的區(qū)別？
答:前者僅是容器中控制權(quán)的轉(zhuǎn)向，在客戶端瀏覽器地址欄中不會顯示出轉(zhuǎn)向后的地址；后者則是完全的跳轉(zhuǎn)，瀏覽器將會得到跳轉(zhuǎn)的地址，并重新發(fā)送請求鏈接。這樣，從瀏覽器的地址欄中可以看到跳轉(zhuǎn)后的鏈接地址。所以，前者更加高效，在前者可以滿足需要時，盡量使用forward()方法，并且，這樣也有助于隱藏實際的鏈接。在有些情況下，比如，需要跳轉(zhuǎn)到一個其它服務(wù)器上的資源，則必須使用sendredirect()方法。77、servlet的基本架構(gòu) 答：
public class servletname extends httpservlet { public void dopost(httpservletrequest request, httpservletresponse response)throws servletexception, ioexception { } public void doget(httpservletrequest request, httpservletresponse response)throws servletexception, ioexception { } }
78、什么情況下調(diào)用doget()和dopost()？
答：jsp頁面中的form標(biāo)簽里的method屬性為get時調(diào)用doget()，為post時調(diào)用dopost()。79、servlet的生命周期
答：web容器加載servlet，生命周期開始。通過調(diào)用servlet的init()方法進行servlet的初始化。通過調(diào)用service()方法實現(xiàn)，根據(jù)請求的不同調(diào)用不同的do***()方法。結(jié)束服務(wù)，web容器調(diào)用servlet的destroy()方法。
80、如何現(xiàn)實servlet的單線程模式 答：<%@ page isthreadsafe=“false”%> 81、頁面間對象傳遞的方法
答：request，session，application，cookie等
82、jsp和servlet有哪些相同點和不同點，他們之間的聯(lián)系是什么？
答：jsp是servlet技術(shù)的擴展，本質(zhì)上是servlet的簡易方式，更強調(diào)應(yīng)用的外表表達。jsp編譯后是“類servlet”。servlet和jsp最主要的不同點在于，servlet的應(yīng)用邏輯是在java文件中，并且完全從表示層中的html里分離開來。的文件。jsp側(cè)重于視圖，servlet主要用于控制邏輯。83、四種會話跟蹤技術(shù)
答：會話作用域servletsjsp 頁面描述
page否是代表與一個頁面相關(guān)的對象和屬性。一個頁面由一個編譯好的 java servlet 類（可以帶有任何的 include 指令，但是沒有 include 動作）表示。這既包括 servlet 又包括被編譯成 servlet 的 jsp 頁面
request是是代表與 web 客戶機發(fā)出的一個請求相關(guān)的對象和屬性。一個請求可能跨越多個頁面，涉及多個 web 組件（由于 forward 指令和 include 動作的關(guān)系）
session是是代表與用于某個 web 客戶機的一個用戶體驗相關(guān)的對象和屬性。一個 web 會話可以也經(jīng)常會跨越多個客戶機請求
application是是代表與整個 web 應(yīng)用程序相關(guān)的對象和屬性。這實質(zhì)上是跨越整個 web 應(yīng)用程序，包括多個頁面、請求和會話的一個全局作用域 84、request對象的主要方法 答：
setattribute(string name,object)：設(shè)置名字為name的request的參數(shù)值 getattribute(string name)：返回由name指定的屬性值
getattributenames()：返回request對象所有屬性的名字集合，結(jié)果是一個枚舉的實例 getcookies()：返回客戶端的所有cookie對象，結(jié)果是一個cookie數(shù)組 getcharacterencoding()：返回請求中的字符編碼方式 getcontentlength()：返回請求的body的長度
getheader(string name)：獲得http協(xié)議定義的文件頭信息 getheaders(string name)：返回指定名字的request header的所有值，結(jié)果是一個枚舉的實例 getheadernames()：返回所以request header的名字，結(jié)果是一個枚舉的實例 getinputstream()：返回請求的輸入流，用于獲得請求中的數(shù)據(jù) getmethod()：獲得客戶端向服務(wù)器端傳送數(shù)據(jù)的方法
getparameter(string name)：獲得客戶端傳送給服務(wù)器端的有name指定的參數(shù)值
getparameternames()：獲得客戶端傳送給服務(wù)器端的所有參數(shù)的名字，結(jié)果是一個枚舉的實例 getparametervalues(string name)：獲得有name指定的參數(shù)的所有值 getprotocol()：獲取客戶端向服務(wù)器端傳送數(shù)據(jù)所依據(jù)的協(xié)議名稱 getquerystring()：獲得查詢字符串
getrequesturi()：獲取發(fā)出請求字符串的客戶端地址 getremoteaddr()：獲取客戶端的ip地址 getremotehost()：獲取客戶端的名字
getsession([boolean create])：返回和請求相關(guān)session getservername()：獲取服務(wù)器的名字
getservletpath()：獲取客戶端所請求的腳本文件的路徑 getserverport()：獲取服務(wù)器的端口號
removeattribute(string name)：刪除請求中的一個屬性
85、我們在web應(yīng)用開發(fā)過程中經(jīng)常遇到輸出某種編碼的字符，如iso8859-1等，如何輸出一個某種編碼的字符串？ 答：
public string translate(string str){ string tempstr = “";try { tempstr = new string(es(”iso-8859-1“), ”gbk");tempstr = ();} catch(exception e){ n(sage());} return tempstr;} 86、servlet執(zhí)行時一般實現(xiàn)哪幾個方法？ 答：
public void init(servletconfig config)public servletconfig getservletconfig()public string getservletinfo()public void service(servletrequest request,servletresponse response)public void destroy()
jdbc、jdo方面88、jdo是什么?
87、e的作用?為什么要用?
答：調(diào)用該訪問返回一個以字符串指定類名的類的對象。答：jdo是java對象持久化的新的規(guī)范，為java data object的簡稱,也是一個用于存取某種數(shù)據(jù)倉庫中的對象的標(biāo)準化api。jdo提供了透明的對象存儲，因此對開發(fā)人員來說，存儲數(shù)據(jù)對象完全不需要額外的代碼（如jdbc api的使用）。這些繁瑣的例行工作已經(jīng)轉(zhuǎn)移到j(luò)do產(chǎn)品提供商身上，使開發(fā)人員解脫出來，從而集中時間和精力在業(yè)務(wù)邏輯上。另外，jdo很靈活，因為它可以在任何數(shù)據(jù)底層上運行。jdbc只是面向關(guān)系數(shù)據(jù)庫（rdbms)jdo更通用，提供到任何數(shù)據(jù)底層的存儲功能，比如關(guān)系數(shù)據(jù)庫、文件、xml以及對象數(shù)據(jù)庫（odbms）等等，使得應(yīng)用可移植性更強。89、說出數(shù)據(jù)連接池的工作機制是什么? 答：j2ee服務(wù)器啟動時會建立一定數(shù)量的池連接，并一直維持不少于此數(shù)目的池連接?？蛻舳顺绦蛐枰B接時，池驅(qū)動程序會返回一個未使用的池連接并將其表記為忙。如果當(dāng)前沒有空閑連接，池驅(qū)動程序就新建一定數(shù)量的連接，新建連接的數(shù)量有配置參數(shù)決定。當(dāng)使用的池連接調(diào)用完成后，池驅(qū)動程序?qū)⒋诉B接表記為空閑，其他調(diào)用就可以使用這個連接。90、jdo是什么? 答：jdo是java對象持久化的新的規(guī)范，為java data object的簡稱,也是一個用于存取某種數(shù)據(jù)倉庫中的對象的標(biāo)準化api。jdo提供了透明的對象存儲，因此對開發(fā)人員來說，存儲數(shù)據(jù)對象完全不需要額外的代碼（如jdbc api的使用）。這些繁瑣的例行工作已經(jīng)轉(zhuǎn)移到j(luò)do產(chǎn)品提供商身上，使開發(fā)人員解脫出來，從而集中時間和精力在業(yè)務(wù)邏輯上。另外，jdo很靈活，因為它可以在任何數(shù)據(jù)底層上運行。jdbc只是面向關(guān)系數(shù)據(jù)庫（rdbms）jdo更通用，提供到任何數(shù)據(jù)底層的存儲功能，比如關(guān)系數(shù)據(jù)庫、文件、xml以及對象數(shù)據(jù)庫（odbms）等等，使得應(yīng)用可移植性更強。
xml方面
91、xml有哪些解析技術(shù)?區(qū)別是什么? 答：有dom,sax,stax等
dom:處理大型文件時其性能下降的非常厲害。這個問題是由dom的樹結(jié)構(gòu)所造成的，這種結(jié)構(gòu)占用的內(nèi)存較多，而且dom必須在解析文件之前把整個文檔裝入內(nèi)存,適合對xml的隨機訪問。
sax:不現(xiàn)于dom,sax是事件驅(qū)動型的xml解析方式。它順序讀取xml文件，不需要一次全部裝載整個文件。當(dāng)遇到像文件開頭，文檔結(jié)束，或者標(biāo)簽開頭與標(biāo)簽結(jié)束時，它會觸發(fā)一個事件，用戶通過在其回調(diào)事件中寫入處理代碼來處理xml文件，適合對xml的順序訪問 stax:streaming api for xml(stax)92、你在項目中用到了xml技術(shù)的哪些方面?如何實現(xiàn)的?
答：用到了數(shù)據(jù)存貯，信息配置兩方面。在做數(shù)據(jù)交換平臺時，將不能數(shù)據(jù)源的數(shù)據(jù)組裝成xml文件，然后將xml文件壓縮打包加密后通過網(wǎng)絡(luò)傳送給接收者，接收解密與解壓縮后再同xml文件中還原相關(guān)信息進行處理。在做軟件配置時，利用xml可以很方便的進行，軟件的各種配置參數(shù)都存貯在xml文件中。
93、xml文檔定義有幾種形式？它們之間有何本質(zhì)區(qū)別？解析xml文檔有哪幾種方式？ 答：a: 兩種形式 dtd schema，b: 本質(zhì)區(qū)別:schema本身是xml的，可以被xml解析器解析(這也是從dtd上發(fā)展schema的根本目的)，c:有dom,sax,stax等
dom:處理大型文件時其性能下降的非常厲害。這個問題是由dom的樹結(jié)構(gòu)所造成的，這種結(jié)構(gòu)占用的內(nèi)存較多，而且dom必須在解析文件之前把整個文檔裝入內(nèi)存,適合對xml的隨機訪問
sax:不現(xiàn)于dom,sax是事件驅(qū)動型的xml解析方式。它順序讀取xml文件，不需要一次全部裝載整個文件。當(dāng)遇到像文件開頭，文檔結(jié)束，或者標(biāo)簽開頭與標(biāo)簽結(jié)束時，它會觸發(fā)一個事件，用戶通過在其回調(diào)事件中寫入處理代碼來處理xml文件，適合對xml的順序訪問 stax:streaming api for xml(stax)
java線程知識點總結(jié) java線程寫法篇三
java線程總結(jié)
首先要理解線程首先需要了解一些基本的東西，我們現(xiàn)在所使用的大多數(shù)操作系統(tǒng)都屬于多任務(wù)，分時操作系統(tǒng)。正是由于這種操作系統(tǒng)的出現(xiàn)才有了多線程這個概念。我們使用的windows,linux就屬于此列。什么是分時操作系統(tǒng)呢，通俗一點與就是可以同一時間執(zhí)行多個程序的操作系統(tǒng)，在自己的電腦上面，你是不是一邊聽歌，一邊聊天還一邊看網(wǎng)頁呢？但實際上，并不上cpu在同時執(zhí)行這些程序，cpu只是將時間切割為時間片，然后將時間片分配給這些程序，獲得時間片的程序開始執(zhí)行，不等執(zhí)行完畢，下個程序又獲得時間片開始執(zhí)行，這樣多個程序輪流執(zhí)行一段時間，由于現(xiàn)在cpu的高速計算能力，給人的感覺就像是多個程序在同時執(zhí)行一樣。
一般可以在同一時間內(nèi)執(zhí)行多個程序的操作系統(tǒng)都有進程的概念.一個進程就是一個執(zhí)行中的程序,而每一個進程都有自己獨立的一塊內(nèi)存空間,一組系統(tǒng)資源.在進程概念中,每一個進程的內(nèi)部數(shù)據(jù)和狀態(tài)都是完全獨立的.因此可以想像創(chuàng)建并執(zhí)行一個進程的系統(tǒng)開像是比較大的，所以線程出現(xiàn)了。在java中，程序通過流控制來執(zhí)行程序流,程序中單個順序的流控制稱為線程,多線程則指的是在單個程序中可以同時運行多個不同的線程,執(zhí)行不同的任務(wù).多線程意味著一個程序的多行語句可以看上去幾乎在同一時間內(nèi)同時運行.（你可以將前面一句話的程序換成進程，進程是程序的一次執(zhí)行過程,是系統(tǒng)運行程序的基本單位）
線程與進程相似,是一段完成某個特定功能的代碼,是程序中單個順序的流控制;但與進程不同的是,同類的多個線程是共享一塊內(nèi)存空間和一組系統(tǒng)資源,而線程本身的數(shù)據(jù)通常只有微處理器的寄存器數(shù)據(jù),以及一個供程序執(zhí)行時使用的堆棧.所以系統(tǒng)在產(chǎn)生一個線程,或者在各個線程之間切換時,負擔(dān)要比進程小的多,正因如此,線程也被稱為輕負荷進程(light-weight process).一個進程中可以包含多個線程.多任務(wù)是指在一個系統(tǒng)中可以同時運行多個程序,即有多個獨立運行的任務(wù),每個任務(wù)對應(yīng)一個進程，同進程一樣,一個線程也有從創(chuàng)建,運行到消亡的過程,稱為線程的生命周期.用線程的狀態(tài)(state)表明線程處在生命周期的哪個階段.線程有創(chuàng)建,可運行,運行中,阻塞,死亡五中狀態(tài).通過線程的控制與調(diào)度可使線程在這幾種狀態(tài)間轉(zhuǎn)化每個程序至少自動擁有一個線程,稱為主線程.當(dāng)程序加載到內(nèi)存時,啟動主線程.[線程的運行機制以及調(diào)度模型]
java中多線程就是一個類或一個程序執(zhí)行或管理多個線程執(zhí)行任務(wù)的能力，每個線程可以獨立于其他線程而獨立運行，當(dāng)然也可以和其他線程協(xié)同運行，一個類控制著它的所有線程，可以決定哪個線程得到優(yōu)先級，哪個線程可以訪問其他類的資源，哪個線程開始執(zhí)行，哪個保持休眠狀態(tài)。下面是線程的機制圖：
page 1 of 16
線程的狀態(tài)表示線程正在進行的活動以及在此時間段內(nèi)所能完成的任務(wù).線程有創(chuàng)建,可運行,運行中,阻塞,死亡五中狀態(tài).一個具有生命的線程,總是處于這五種狀態(tài)之一： 1.創(chuàng)建狀態(tài)
使用new運算符創(chuàng)建一個線程后,該線程僅僅是一個空對象,系統(tǒng)沒有分配資源,稱該線程處于創(chuàng)建狀態(tài)(new thread)2.可運行狀態(tài)
使用start()方法啟動一個線程后,系統(tǒng)為該線程分配了除cpu外的所需資源,使該線程處于可運行狀態(tài)(runnable)3.運行中狀態(tài)
java運行系統(tǒng)通過調(diào)度選中一個runnable的線程,使其占有cpu并轉(zhuǎn)為運行中狀態(tài)(running).此時,系統(tǒng)真正執(zhí)行線程的run()方法.4.阻塞狀態(tài)
一個正在運行的線程因某種原因不能繼續(xù)運行時,進入阻塞狀態(tài)(blocked)5.死亡狀態(tài)
線程結(jié)束后是死亡狀態(tài)(dead)
同一時刻如果有多個線程處于可運行狀態(tài),則他們需要排隊等待cpu資源.此時每個線程自動獲得一個線程的優(yōu)先級(priority),優(yōu)先級的高低反映線程的重要或緊急程度.可運行狀態(tài)的線程按優(yōu)先級排隊,線程調(diào)度依據(jù)優(yōu)先級基礎(chǔ)上的“先到先服務(wù)”原則.線程調(diào)度管理器負責(zé)線程排隊和cpu在線程間的分配,并由線程調(diào)度算法進行調(diào)度.當(dāng)線程調(diào)度管理器選種某個線程時,該線程獲得cpu資源而進入運行狀態(tài).線程調(diào)度是先占式調(diào)度,即如果在當(dāng)前線程執(zhí)行過程中一個更高優(yōu)先級的線程進入可運行狀態(tài),則這個線程立即被調(diào)度執(zhí)行.先占式調(diào)度分為:獨占式和分時方式.獨占方式下,當(dāng)前執(zhí)行線程將一直執(zhí)行下去,直 到執(zhí)行完畢或由于某種原因主動放棄cpu,或cpu被一個更高優(yōu)先級的線程搶占
分時方式下,當(dāng)前運行線程獲得一個時間片,時間到時,即使沒有執(zhí)行完也要讓出
page 2 of 16
cpu,進入可運行狀態(tài),等待下一個時間片的調(diào)度.系統(tǒng)選中其他可運行狀態(tài)的線程執(zhí)行
分時方式的系統(tǒng)使每個線程工作若干步,實現(xiàn)多線程同時運行
另外請注意下面的線程調(diào)度規(guī)則（如果有不理解，不急，往下看）： ①如果兩個或是兩個以上的線程都修改一個對象，那么把執(zhí)行修改的方法定義為被同步的（synchronized）,如果對象更新影響到只讀方法，那么只度方法也應(yīng)該定義為同步的
②如果一個線程必須等待一個對象狀態(tài)發(fā)生變化，那么它應(yīng)該在對象內(nèi)部等待，而不是在外部等待，它可以調(diào)用一個被同步的方法，并讓這個方法調(diào)用wait()③每當(dāng)一個方法改變某個對象的狀態(tài)的時候，它應(yīng)該調(diào)用notifyall()方法，這給等待隊列的線程提供機會來看一看執(zhí)行環(huán)境是否已發(fā)生改變
④記住wait(),notify(),notifyall()方法屬于object類，而不是thread類，仔細檢查看是否每次執(zhí)行wait()方法都有相應(yīng)的notify()或notifyall()方法，且它們作用與相同的對象 在java中每個類都有一個主線程，要執(zhí)行一個程序，那么這個類當(dāng)中一定要有main方法，這個man方法也就是java class中的主線程。你可以自己創(chuàng)建線程，有兩種方法，一是繼承thread類，或是實現(xiàn)runnable接口。一般情況下，最好避免繼承，因為java中是單根繼承，如果你選用繼承，那么你的類就失去了彈性，當(dāng)然也不能全然否定繼承thread,該方法編寫簡單,可以直接操作線程,適用于單重繼承情況。至于選用那一種，具體情況具體分析。
eg.繼承thread
public class mythread_1 extends thread{ public void run(){ //some code } }
eg.實現(xiàn)runnable接口
public class mythread_2 implements runnable { public void run(){ //some code } }
page 3 of 16
當(dāng)使用繼承創(chuàng)建線程，這樣啟動線程：
new mythread_1().start()
當(dāng)使用實現(xiàn)接口創(chuàng)建線程，這樣啟動線程：
new thread(new mythread_2()).start()
注意，其實是創(chuàng)建一個線程實例，并以實現(xiàn)了runnable接口的類為參數(shù)傳入這個實例，當(dāng)執(zhí)行這個線程的時候，mythread_2中run里面的代碼將被執(zhí)行。下面是完成的例子：
public class mythread implements runnable { public void run(){ n(“my name is ”+tthread().getname());} public static void main(string[] args){ new thread(new mythread()).start();} }
執(zhí)行后將打印出： my name is thread-0
你也可以創(chuàng)建多個線程，像下面這樣
new thread(new mythread()).start();new thread(new mythread()).start();new thread(new mythread()).start();
那么會打印出：
my name is thread-0 my name is thread-1
page 4 of 16
my name is thread-2
看了上面的結(jié)果，你可能會認為線程的執(zhí)行順序是依次執(zhí)行的，但是那只是一般情況，千萬不要用以為是線程的執(zhí)行機制；影響線程執(zhí)行順序的因素有幾點：首先看看前面提到的優(yōu)先級別
public class mythread implements runnable { public void run(){ n(“my name is ”+tthread().getname());} public static void main(string[] args){ thread t1=new thread(new mythread());thread t2=new thread(new mythread());thread t3=new thread(new mythread());
ority(_priority);//賦予最高優(yōu)先級
();();();} }
再看看結(jié)果：
my name is thread-1 my name is thread-0 my name is thread-2
page 5 of 16
線程的優(yōu)先級分為10級，分別用1到10的整數(shù)代表，默認情況是5。上面的ority(_priority)ority(10）
然后是線程程序本身的設(shè)計，比如使用sleep,yield,join，wait等方法（詳情請看jdkdocument)
public class mythread implements runnable { public void run(){
try {
int sleeptime =(int)(()* 100);// 產(chǎn)生隨機數(shù)字，tthread().sleep(sleeptime);// 讓其休眠一定時間，時間又上面sleeptime決定
// public static void sleep(long millis)throw interruptedexception
//（api）
n(tthread().getname()+ “ 睡了 ”
+ sleeptime);
} catch(interruptedexception ie)
// 由于線程在休眠可能被中斷，所以調(diào)用sleep方法的時候需要捕捉異常
page 6 of 16
{
tacktrace();
} }
public static void main(string[] args){
thread t1 = new thread(new mythread());
thread t2 = new thread(new mythread());
thread t3 = new thread(new mythread());
();
();
();} }
執(zhí)行后觀察其輸出： thread-0 睡了 11 thread-2 睡了 48 thread-1 睡了 69
上面的執(zhí)行結(jié)果是隨機的，再執(zhí)行很可能出現(xiàn)不同的結(jié)果。由于上面我在run中添加了休眠語句，當(dāng)線程休眠的時候就會讓出cpu，cpu將會選擇執(zhí)行處于runnable狀態(tài)中的其他線程，當(dāng)然也可能出現(xiàn)這種情況，休眠的thread立即進入了runnable狀態(tài)，cpu再次執(zhí)行它。[線程組概念] 線程是可以被組織的，java中存在線程組的概念，每個線程都是一個線程組的成員,線程組把多個線程集成為一個對象,通過線程組可以同時對其中的多個線程進行操作,包中的thread——group類用來管理一組線程,包括:線程的數(shù)目,線程間的關(guān)系,線程正在執(zhí)行的操作,以及線程將要啟動或終止時間等.線程組還可以包含線程組.在java的應(yīng)用程序中,最高層的線程組是名位main的線程組,在main中還可以加入線程或
page 7 of 16
線程組,在mian的子線程組中也可以加入線程和線程組,形成線程組和線程之間的樹狀繼承關(guān)系。像上面創(chuàng)建的線程都是屬于main這個線程組的。借用上面的例子，main里面可以這樣寫：
public static void main(string[] args){
/***************************************
* threadgroup(string name)threadgroup(threadgroup parent, string name)
***********************************/
threadgroup group1 = new threadgroup(“group1”);
threadgroup group2 = new threadgroup(group1, “group2”);
thread t1 = new thread(group2, new mythread());
thread t2 = new thread(group2, new mythread());
thread t3 = new thread(group2, new mythread());
();
();
();} 線程組的嵌套，t1,t2,t3被加入group2,group2加入group1。
page 8 of 16
另外一個比較多就是關(guān)于線程同步方面的，試想這樣一種情況，你有一筆存款在銀行，你在一家銀行為你的賬戶存款，而你的妻子在另一家銀行從這個賬戶提款，現(xiàn)在你有1000塊在你的賬戶里面。你存入了1000，但是由于另一方也在對這筆存款進行操作，人家開始執(zhí)行的時候只看到賬戶里面原來的1000元，當(dāng)你的妻子提款1000元后，你妻子所在的銀行就認為你的賬戶里面沒有錢了，而你所在的銀行卻認為你還有2000元?？纯聪旅娴睦樱?/p>
class blanksaving // 儲蓄賬戶 { private static int money = 10000;
public void add(int i){
money = money + i;
n(“husband 向銀行存入了 [￥” + i + “]”);}
public void get(int i){
money = money-i;
n(“wife 向銀行取走了 [￥” + i + “]”);
if(money < 0)
n(“余額不足！”);}
page 9 of 16
public int showmoney(){
return money;} }
class operater implements runnable { string name;blanksaving bs;
public operater(blanksaving b, string s){
name = s;
bs = b;
}
public static void oper(string name, blanksaving bs){
if((“husband”)){
try {
for(int i = 0;i < 10;i++){
page 10 of 16
tthread().sleep((int)(()* 300));
(1000);
}
} catch(interruptedexception e){
}
} else {
try {
for(int i = 0;i < 10;i++){
tthread().sleep((int)(()* 300));
(1000);
}
} catch(interruptedexception e){
}
} }
public void run(){
oper(name, bs);}
page 11 of 16
}
public class banktest { public static void main(string[] args)throws interruptedexception {
blanksaving bs = new blanksaving();
operater o1 = new operater(bs, “husband”);
operater o2 = new operater(bs, “wife”);
thread t1 = new thread(o1);
thread t2 = new thread(o2);
();
();
tthread().sleep(500);} }
下面是其中一次的執(zhí)行結(jié)果：
---------first--------------husband 向銀行存入了 [￥1000] wife 向銀行取走了 [￥1000] wife 向銀行取走了 [￥1000] husband 向銀行存入了 [￥1000] wife 向銀行取走了 [￥1000] husband 向銀行存入了 [￥1000] wife 向銀行取走了 [￥1000] husband 向銀行存入了 [￥1000] wife 向銀行取走了 [￥1000] husband 向銀行存入了 [￥1000] husband 向銀行存入了 [￥1000]
page 12 of 16
wife 向銀行取走了 [￥1000] husband 向銀行存入了 [￥1000] husband 向銀行存入了 [￥1000] wife 向銀行取走了 [￥1000] wife 向銀行取走了 [￥1000] husband 向銀行存入了 [￥1000] wife 向銀行取走了 [￥1000] wife 向銀行取走了 [￥1000] husband 向銀行存入了 [￥1000]
看到了嗎，這可不是正確的需求，在husband還沒有結(jié)束操作的時候，wife就插了進來，這樣很可能導(dǎo)致意外的結(jié)果。解決辦法很簡單，就是將對數(shù)據(jù)進行操作方法聲明為synchronized,當(dāng)方法被該關(guān)鍵字聲明后，也就意味著，如果這個數(shù)據(jù)被加鎖，只有一個對象得到這個數(shù)據(jù)的鎖的時候該對象才能對這個數(shù)據(jù)進行操作。也就是當(dāng)你存款的時候，這筆賬戶在其他地方是不能進行操作的，只有你存款完畢，銀行管理人員將賬戶解鎖，其他人才能對這個賬戶進行操作。
修改public static void oper(string name,blanksaving bs)為public static void oper(string name,blanksaving bs)，再看看結(jié)果:
husband 向銀行存入了 [￥1000] husband 向銀行存入了 [￥1000] husband 向銀行存入了 [￥1000] husband 向銀行存入了 [￥1000] husband 向銀行存入了 [￥1000] husband 向銀行存入了 [￥1000] husband 向銀行存入了 [￥1000] husband 向銀行存入了 [￥1000] husband 向銀行存入了 [￥1000] husband 向銀行存入了 [￥1000] wife 向銀行取走了 [￥1000] wife 向銀行取走了 [￥1000] wife 向銀行取走了 [￥1000] wife 向銀行取走了 [￥1000] wife 向銀行取走了 [￥1000] wife 向銀行取走了 [￥1000] wife 向銀行取走了 [￥1000] wife 向銀行取走了 [￥1000] wife 向銀行取走了 [￥1000] wife 向銀行取走了 [￥1000]
當(dāng)丈夫完成操作后，妻子才開始執(zhí)行操作，這樣的話，對共享對象的操作就不會有問題了。
[wait and notify] 你可以利用這兩個方法很好的控制線程的執(zhí)行流程，當(dāng)線程調(diào)用wait方法后，線
page 13 of 16
程將被掛起，直到被另一線程喚醒（notify）或則是如果wait方法指定有時間得話，在沒有被喚醒的情況下，指定時間時間過后也將自動被喚醒。但是要注意一定，被喚醒并不是指馬上執(zhí)行，而是從組塞狀態(tài)變?yōu)榭蛇\行狀態(tài)，其是否運行還要看cpu的調(diào)度。事例代碼：
class mythread_1 extends thread {
object lock;
public mythread_1(object o){
lock = o;}
public void run(){
try {
synchronized(lock){
n(“enter thread_1 and wait”);
();
n(“be notified”);
}
} catch(interruptedexception e){
} }
page 14 of 16
}
class mythread_2 extends thread { object lock;
public mythread_2(object o){
lock = o;}
public void run(){
synchronized(lock){
n(“enter thread_2 and notify”);
();
} } }
public class mythread { public static void main(string[] args){
int[] in = new int[0];// notice
mythread_1 t1 = new mythread_1(in);
page 15 of 16
mythread_2 t2 = new mythread_2(in);
();
();} }
執(zhí)行結(jié)果如下：
enter thread_1 and wait enter thread_2 and notify thread_1 be notified
可能你注意到了在使用wait and notify方法得時候我使用了synchronized塊來包裝這兩個方法，這是由于調(diào)用這兩個方法的時候線程必須獲得鎖，也就是上面代碼中的lock[]，如果你不用synchronized包裝這兩個方法的得話，又或則鎖不一是同一把，比如在mythread_2中synchronized(lock)改為synchronized(this),lmonitorstateexception執(zhí)行期異常。另外wait and notify方法是object中的，并不在thread這個類中。最后你可能注意到了這點：int[] in=new int[0];為什么不是創(chuàng)建new object而是一個0長度的數(shù)組，那是因為在java中創(chuàng)建一個0長度的數(shù)組來充當(dāng)鎖更加高效。
page 16 of 16
java線程知識點總結(jié) java線程寫法篇四
1.什么是gui?
a)gui是graphics user interface的全稱,意思是圖形用戶界面.2.為什么需要gui?
a)圖形用戶界面能夠讓最終用戶通過鼠標(biāo)拖動、單擊等動作就可以操作整個應(yīng)用,從而提高應(yīng)用的用戶體驗效果,
a)awt是sun公司提供的一個基本的gui類庫,被稱為抽象工具集(abstract
window-toolkit),它為java應(yīng)用程序提供了基本的組件.b)awt組件需要調(diào)用運行平臺的圖形界面來創(chuàng)建和平臺一致的對等體,所以awt只
能使用所有平臺都支持的公共組件,因此awt只能夠提供一些 的主要組成部分
a)component,代表一個具體圖形表示能力的對象,可以在屏幕上顯示,并與用戶交互.通常我們把它稱為”組件”.b)menucomponent,r,,em,代表一個菜單項.c)container,代表一個awt組件容器,可以盛裝其他commponent組件,它繼承自
component抽象類,,,,代表一個對話框
a)filedialog代表一個文件對話框,,可容納其他組件,但不能獨立存在,必須被添加到其他容器中.ii.scrollpane,帶滾動條的容器.d)layoutmanager,布局管理器,yout,流式布局,layout,邊框布局,只能盛裝5個組件,yout,網(wǎng)格布局,glayout,網(wǎng)格包布局,一種較為復(fù)雜的布局管理器,yout,卡片布局,以時間來管理容器內(nèi)的組件,將組件看作是一張張卡片,每次顯示最外面一張卡片(組件).boxlayou,箱式布局, 的事件
a)應(yīng)用程序響應(yīng)用戶的某個動作或請求,如用戶單擊了一下鼠標(biāo),用戶請求關(guān)閉應(yīng)用
程序窗口等.b)awt編程中,所有事件的處理都必須交給特定的對象來完成,我們將這個特定的對
象稱為事件監(jiān)聽器.c)awt的事件處理機制是一種委派式的事件處理方式,通過將某個事件監(jiān)聽器注冊
到用戶指定的組件,當(dāng)用戶進行某個操作并觸發(fā)指定事件時,應(yīng)用程序會自動產(chǎn)生一個事件(event)對象并作為參數(shù)傳給事件監(jiān)聽器中的事件處理器,然后由事件監(jiān)
聽器通知事件處理器來響應(yīng)用戶,完成用戶的請求.d)不同的事件需要不同的事件監(jiān)聽器,不同的監(jiān)聽器需要實現(xiàn)不同的監(jiān)聽器接口.e)事件監(jiān)聽器接口:為某個特定事件定義了響應(yīng)用戶請求的方法,當(dāng)用戶將某個事件
監(jiān)聽器注冊到指定組件上以響應(yīng)特定的事件時,則該事件監(jiān)聽器必須實現(xiàn)對應(yīng)的事件監(jiān)聽器接口才能對用戶的請求進行有效處理.例如,用戶點擊了鼠標(biāo)右鍵,希望打開某個應(yīng)用程序的右鍵菜單,則注冊到該應(yīng)用程序上的事件監(jiān)聽器必須實現(xiàn)鼠標(biāo)事件監(jiān)聽器接口,并實現(xiàn)該接口內(nèi)部某些方法來完成用戶的請求.f)事件適配器,很多時候,我們只需要實現(xiàn)某個事件監(jiān)聽器接口中個別方法就能完成應(yīng)用程序的實際需求,但實現(xiàn)該事件監(jiān)聽器接口的類必須實現(xiàn)該接口中所有的抽象方法,這會造成代碼的冗余.而事件適配器可以幫我們解決這個問題,事件適配器實現(xiàn)了所有的擁有多個抽象方法的事件監(jiān)聽器接口,并空實現(xiàn)了這些接口中所有的抽象方法,所謂空實現(xiàn),就是方法中沒有任何實現(xiàn)代碼,因此,我們可以通過繼承對應(yīng)事件監(jiān)聽器接口的事件適配器抽象類,并實現(xiàn)我們感興趣的方法來完成應(yīng)用需求即可.g)java事件處理過程中主要涉及的三類對象
i.事件源,.事件,通常指用戶的某個操作,如單擊了一下鼠標(biāo),.事件監(jiān)聽器,負責(zé)監(jiān)聽事件源上所發(fā)生的事件,并作出響應(yīng).h)awt事件監(jiān)聽器的實現(xiàn)形式
.內(nèi)部類形式 頂級類形式
iii.類本身作為事件監(jiān)聽器
iv.匿名內(nèi)部類形式
v.注:繪圖
a)awt繪圖的實現(xiàn)過程.i.重寫畫布類的paint方法,.調(diào)用component類的repaint方法繪制圖形.b)awt實現(xiàn)繪圖主要涉及的對象
.c)component類的子類canvas類,cs,代表一個畫筆,類代表了位圖,它的一個主要的實現(xiàn)類bufferedimage是可以訪問圖形數(shù)據(jù)
緩沖區(qū),并可以返回一個graphics對象來繪制該buuferedimage.d)的優(yōu)缺點
a)awt在許多非桌面環(huán)境,如嵌入式設(shè)備中有著自己的優(yōu)勢,它的主要優(yōu)點如下:.iv.更少的內(nèi)存：對運行在有限環(huán)境中的gui程序的開發(fā)，是合適的。2.更少的啟動事件：由于awt組件是本地由操作系統(tǒng)實現(xiàn)的。絕大多數(shù)的二進制代碼已經(jīng)在如系統(tǒng)啟動的時候被預(yù)裝載了，這降低了它的啟動事件。3.更好的響應(yīng)：由于本地組件由操作系統(tǒng)渲染。4.成熟穩(wěn)定的：能夠正常工作并很少使你的程序崩潰。
b)同樣它也有不少的缺點
.更少組件類型：表和樹這些重要的組件缺失了。它們是桌面應(yīng)用程序中普遍使用的。2.缺乏豐富的組件特征：按鈕不支持圖片。3.無擴展性：awt的組件是本地組件。jvm中的awt類實例實際只是包含本地
組件的引用。唯一的擴展點是awt的canvas組件，可以從零開始創(chuàng)建自定義組
件。然而無法繼承和重用一個已有的awt組件
總結(jié):awt是sun不推薦使用的工具集,實際開發(fā)中很少使用awt而是使用sun公司
和netscape公司共同開發(fā)的一個新的用戶界面庫-swing來開發(fā)gui應(yīng)用程序,awt是圖形用戶界面編程的基礎(chǔ),它的布局管理、事件機制、剪貼板操作等內(nèi)容仍然適用于swing gui編程.
java線程知識點總結(jié) java線程寫法篇五
in the following code, which is the earliest statement, where the object originally held in e, may be garbage collected:
class test {
static void main(string args []){
ee e = new employee(“bob”, 48);
atepay();
n(etails());
6.e = null;
7.e = new employee(“denise”, 36);
atepay();
n(etails());
10.}
11.}
only one:
in the following code, which is the earliest statement, where the object originally held in e, may be garbage collected:
class test {
static void main(string args []){
ee e = new employee(“bob”, 48);
atepay();
n(etails());
6.e = null;
7.e = new employee(“denise”, 36);
atepay();
n(etails());
10.}
11.}
only one:
10
11
7
8
2:exhibit :
class test（e static int j = 0;
e static boolean methodb(int k)（5.j += k;
true;
6.)
static void methoda(int i){
n b:
10.b = i < 10 | methodb(4);
11.b = i < 10 || methodb(8);
12.)
static void main(string args[] }（a(0);
n(j);
17.)
18.)
what is the result?
program prints “0”
program prints “4”
program prints “8”
program prints “12”
3:what is written to the standard output given the following statement:n(4|7);
select the right answer:
a.4
b.5
c.6
d.7
4:
select valid identifier of java:
select valid identifier of java:
a.%passwd
b.3d_game
c.$charge
5:設(shè)有變量說明語句int a=1,b=0;
則執(zhí)行以下程序段的輸出結(jié)果為()。
switch(a)
{
case 1:
switch(b)
{
case 0:printf(“**0**”);break;
case 1:printf(“**1**”);break;
}
case 2:printf(“**2**”);break;
}
printf(“ ”);
a.**0**
b.**0****2**
c.**0****1****2**
d.有語法錯誤
6:in the following pieces of code, which one will compile without any error?
buffer sb1 = “abcd”;
n b = new boolean(“abcd”);
c.c: byte b = 255;
fl = 1.2;
7:
what is the result when you compile and run the following code?
public class throwsdemo
{
static void throwmethod()
{
n(“inside throwmethod.”);
throw new illegalaccessexception(“demo”);
}
public static void main(string args[])
{
try
{
throwmethod();
}
catch(illegalaccessexception e)
{
n(“caught ” + e);
}
}
}
choices:
what is the result when you compile and run the following code?
public class throwsdemo
{
static void throwmethod()
{
n(“inside throwmethod.”);
throw new illegalaccessexception(“demo”);
}
public static void main(string args[])
{
try
{
throwmethod();
}
catch(illegalaccessexception e)
{
n(“caught ” + e);
}
}
}
choices:
ation error
e error
e successfully, nothing is ed by caught:laccessexcption: demo
8:which of the following statements are not legal?
l = 4990;
i = 4l;
d = 34.4;
t = 0.9f.9:
give the following java class:
public class example{
public static void main(string args[]){
static int x[] = new int[15];
n(x[5]);
}
}
which statement is corrected?
give the following java class:
public class example{
public static void main(string args[]){
static int x[] = new int[15];
n(x[5]);
}
}
which statement is corrected?
compile, some error will run, some error will is is null.10:下面關(guān)于變量及其范圍的陳述哪些是錯的。
a.實例變量是類的成員變量。
b.實例變量用關(guān)鍵字static聲明。
c.在方法中定義的局部變量在該方法被執(zhí)行時創(chuàng)建
d.局部變量在使用前必須被初始化。
11:
public class x{
public object m(){
object o = new float(3.14f);//line 3
object [] oa = new object[1];//line 4
oa[0] = o;//line 5
o=null;//line 6
return oa[0];//line 7
}
}
when is the float object, created in line 3,eligible for garbage collection?
public class x{
public object m(){
object o = new float(3.14f);//line 3
object [] oa = new object[1];//line 4
oa[0] = o;//line 5
o=null;//line 6
return oa[0];//line 7
}
}
when is the float object, created in line 3,eligible for garbage collection?
after line after line 6
after line 7(that is,as the method returns)
in this method
12:
which is the most appropriate code snippet that can be inserted at line 18 in the following code?
(assume that the code is compiled and run with assertions enabled)
.*;
class asserttest
4.{
e hashmap cctld;
asserttest()
8.{
= new hashmap();
(“in”, “india”);
(“uk”, “united kingdom”);
(“au”, “australia”);
13.// more code...14.}
15.// other methods.... string getcountry(string countrycode)
17.{
18.// what should be inserted here?
country =(string)(countrycode);
country;
21.}
22.}
which is the most appropriate code snippet that can be inserted at line 18 in the following code?
(assume that the code is compiled and run with assertions enabled)
.*;
class asserttest
4.{
e hashmap cctld;
asserttest()
8.{
= new hashmap();
(“in”, “india”);
(“uk”, “united kingdom”);
(“au”, “australia”);
13.// more code...14.}
15.// other methods.... string getcountry(string countrycode)
17.{
18.// what should be inserted here?
country =(string)(countrycode);
country;
21.}
22.}
countrycode!= null;
countrycode!= null : “country code can not be null”;
cctld!= null : “no country code data is available”;
cctld : “no country code data is available”;
13:
give the following code:
public class example{
public static void main(string args[]){
int l=0;
do{
n(“doing it for l is:”+l);
}while(—l>0)
n(“finish”);
}
}
which well be output:
give the following code:
public class example{
public static void main(string args[]){
int l=0;
do{
n(“doing it for l is:”+l);
}while(—l>0)
n(“finish”);
}
}
which well be output:
it for l is 3
it for l is 1
it for l is 2
it for l is 0
14:which statements about java code security are not true?
bytecode verifier loads all classes needed for the execution of a ing code is performed by the runtime runtime the bytecodes are loaded, checked and run in an interpreter. class loader adds security by separating the namespaces for the classes of the local file system from those imported from network sources.15:a class design requires that a member variable should be accessible only by same package, which modifer word should be used?
ted
modifer
e
16:character流與byte流的區(qū)別是
a.每次讀入的字節(jié)數(shù)不同
b.前者帶有緩沖，后者沒有
c.前者是塊讀寫，后者是字節(jié)讀寫
d.二者沒有區(qū)別，可以互換使用
簡答題
17:找出兩個字符串中最大子字符串,如“abractyeyt”,“dgdsaeactyey”的最大子串為“actyet”
18:假設(shè)你有一個用1001個整數(shù)組成的數(shù)組，這些整數(shù)是任意排列的，但是你知道所有的整數(shù)都在1到1000(包括1000)之間。此外，除一個數(shù)字出現(xiàn)兩次外，其他所有數(shù)字只出現(xiàn)一次。假設(shè)你只能對這個數(shù)組做一次處理，用一種算法找出重復(fù)的那個數(shù)字。如果你在運算中使用了輔助的存儲方式，那么你能找到不用這種方式的算法嗎?
19:到底在哪里使用cascade=“...”?
20:使用tomcat部署應(yīng)用程序 emoryerror 嗎?如何解決的。
21:請寫一個java程序?qū)崿F(xiàn)數(shù)據(jù)庫緩沖池的功能?
22:有200個正整數(shù)，且每個數(shù)均在1000至9999之間。請編制函數(shù)，其函數(shù)的功能是：要求按每個數(shù)的后三位的大小進行升序排列，然后取出滿足此條件的前10個數(shù)依次存入數(shù)組bb中，如果后三位的數(shù)值相等，則按原先的數(shù)值進行降序排列。
23:anonymous inner class(匿名內(nèi)部類)是否可以extends(繼承)其它類，是否可以implements(實現(xiàn))interface(接口)?
24:找出字符串a(chǎn)中包含的字符可以進行的所有不同組合。例如：abccd中，ab，ac，bc，cc，abd等都是可能的組合。
25:下面的代碼在絕大部分時間內(nèi)都運行得很正常，請問在什么情況下會出現(xiàn)問題?問題的根源在哪里?
import .linkedlist;
public class stack {
linkedlist list = new linkedlist();
public synchronized void push(object x){
synchronized(list){
t(x);
notify();
}
}
public synchronized object pop()
throws exception {
synchronized(list){
if(()<= 0){
wait();
}
return last();
}
}
}
【本文地址：http://mlvmservice.com/zuowen/1082486.html】
