Account Optio This is a Usenet group -
View this group in the
Cuda Q2: Branch Divergence Serialization (Threads/hardware stalls ?) Performance Impact ?
There are currently too many topics in this group that di lay first. To make this topic a ear first, remove this option from another topic.
There was an error proce ing your request. Please try again.
Standard view 8
me ages - - The group you are posting to is a
. Me ages posted to this group will make your email addre visible to anyone on the Internet.
Your reply me age has not been sent.
Your post was succe ful
Send Discard
Followup To:
Add Followup-to
Edit Subject
Subject:
Validation:
For verification purposes please type the characters you see in the picture below or the numbers you hear by clicking the acce ibility icon.
Send Discard
Skybuck Flying More optio Jun 8, 6:30 m
Newsgrou :
comp.arch
Skybuck Flying Windows7I
@DreamPC2006.com
Thu, 9 Jun 2011 00:30:31 +0200
Wed, Jun 8 2011 6:30 m
Subject:
Cuda Q2: Branch Divergence Serialization (Threads/hardware stalls ?) Performance Impact ?
Cuda Question 2:
(Perha there are some cha in here that know a thing or two about
nvidia's gpu's (gpus?;)) and the way they operate ;))
(Cuda Experience: noobie Cuda Coding stage: pla ing)
For cuda it is claimed that threads will start to do other things as
it/they(?) schedules load requests from/for memory.
My question is about " ranch divergence serializatio quot; (within a single warp
It is said that if threads within a warp diverge on branches that they
will be " erialized, so this would slow down the threads somewhat.
What exactly ha e ? How much of a performance penalty is it ? How many
cycles do branches takes ? And how many cycles would it take for worst case
scenerio ?
For the looks of it thread quot; within a warp behave like SSE so they like
it if there is no branching or at least little divergence, so it seems to be
" ingle i truction multiple data.
If that is indeed the case, then perha serialization would be really bad
for the performance within a warp.
So the question is what exactly ha e to thread quot; which are serialized
Will they (or their hardware allocation which was su osed to execute them)
start to do something else (like threads being stalled by memory request and
go do something else ?????) ? Or will these threads simply " tall on the
serializatio quot; (queue?) and simply be waiting and doing nothing ?
Also if a warp is like an SSE execution unit then how come threads can post
multiple memory request per thread ? I gue this a umes that data is also
pointers/indexes to memory so then it can indeed do multiple memory
requests... does data need to be near each other (like an xmm register) or
not (can it be random memory acce /random memory locatio ) for eedy warp
execution... ?
Skybuck. You must
before you can post me ages.
To post a me age you must first
Please update your nickname on the
page before posting.
You do not have the permi ion required to post.
Skybuck Flying More optio Jun 8, 6:32 m
Newsgrou :
alt.comp.periphs.videocards.nvidia.programming, comp.arch
Skybuck Flying Windows7I
@DreamPC2006.com
Thu, 9 Jun 2011 00:32:14 +0200
Wed, Jun 8 2011 6:32 m
Subject:
Cuda Q2: Branch Divergence Serialization (Threads/hardware stalls ?) Performance Impact ?
Cuda Question 2:
(Perha there are some cha in here that know a thing or two about
nvidia's gpu's (gpus?;)) and the way they operate ;))
(Cuda Experience: noobie Cuda Coding stage: pla ing)
For cuda it is claimed that threads will start to do other things as
it/they(?) schedules load requests from/for memory.
My question is about " ranch divergence serializatio quot; (within a single warp
It is said that if threads within a warp diverge on branches that they
will be " erialized, so this would slow down the threads somewhat.
What exactly ha e ? How much of a performance penalty is it ? How many
cycles do branches takes ? And how many cycles would it take for worst case
scenerio ?
For the looks of it thread quot; within a warp behave like SSE so they like
it if there is no branching or at least little divergence, so it seems to be
" ingle i truction multiple data.
If that is indeed the case, then perha serialization would be really bad
for the performance within a warp.
So the question is what exactly ha e to thread quot; which are serialized
Will they (or their hardware allocation which was su osed to execute them)
start to do something else (like threads being stalled by memory request and
go do something else ?????) ? Or will these threads simply " tall on the
serializatio quot; (queue?) and simply be waiting and doing nothing ?
Also if a warp is like an SSE execution unit then how come threads can post
multiple memory request per thread ? I gue this a umes that data is also
pointers/indexes to memory so then it can indeed do multiple memory
requests... does data need to be near each other (like an xmm register) or
not (can it be random memory acce /random memory locatio ) for eedy warp
execution... ?
Skybuck.
(Reposting/cro ost for/to nvidia programming newsgroup too, so reply to
this one if you want them to see it too ;)) You must
before you can post me ages.
To post a me age you must first
Please update your nickname on the
page before posting.
You do not have the permi ion required to post.
Skybuck Flying More optio Jun 8, 7:10 m
Newsgrou :
alt.comp.periphs.videocards.nvidia.programming, comp.arch
Skybuck Flying Windows7I
@DreamPC2006.com
Thu, 9 Jun 2011 01:10:33 +0200
Wed, Jun 8 2011 7:10 m
Subject:
Re: Cuda Q2: Branch Divergence Serialization (Threads/hardware stalls ?) Performance Impact ?
Hmm more info and seems a bit more recent:
14 microseconds sync call.
4 microseconds async call.
Worst case kernel calls per second: 72.000
Best case kernel calls per second: 334.000
That's a big ouch ! Compared to CPU:
300.000.000 function calls per second.
Seems like nvidia has their work cut out for them...
A erently these calls go through a driver.
This is probably why nvidia is trying to work on an arm chip that will
integrate into the gpu, hopefully the arm chip will be able to i ue kernel
calls much faster.
That would be cool, I gue , as long as the gpu can also execute as fast as
the arm chip can call it/them ;) (In this case an empty gpu function/kernel
call may be co idered ;):))
Bye, Skybuck. You must
before you can post me ages.
To post a me age you must first
Please update your nickname on the
page before posting.
You do not have the permi ion required to post.
MitchAlsup More optio Jun 8, 8:14 m
Newsgrou :
alt.comp.periphs.videocards.nvidia.programming, comp.arch
MitchAlsup MitchAl
@aol.com
Wed, 8 Jun 2011 17:14:31 -0700 (PDT)
Wed, Jun 8 2011 8:14 m
Subject:
Re: Cuda Q2: Branch Divergence Serialization (Threads/hardware stalls ?) Performance Impact ?
On Jun 8, 6:10爌m, Skybuck Flying Windows7I
@DreamPC2006.com
This is probably why nvidia is trying to work on an arm chip that will
integrate into the gpu, hopefully the arm chip will be able to i ue kernel
calls much faster.
I think it has more to do with Intel having its own on-die GPU, AMD
has its captured (ATI) on-die GPU, leaving nVidia out of the volume
game. It still has the ultra-high-end GPUs that su ort gammers.
Mitch You must
before you can post me ages.
To post a me age you must first
Please update your nickname on the
page before posting.
You do not have the permi ion required to post.
Skybuck Flying More optio Jun 8, 8:48 m
Newsgrou :
alt.comp.periphs.videocards.nvidia.programming, comp.arch
Skybuck Flying Windows7I
@DreamPC2006.com
Thu, 9 Jun 2011 02:48:51 +0200
Wed, Jun 8 2011 8:48 m
Subject:
Re: Cuda Q2: Branch Divergence Serialization (Threads/hardware stalls ?) Performance Impact ?
As far as I know intel's integrated gpu's are all shitty... and it's not
just about gpu.. it's also about software su orting the gpu... like
drivers/opengl drivers... intel might be lacking in that department...
Anyway if you disagree or believe intel actually has a gpu comparable to
radeon 3300 or gt 520 let me know ! ;)
Bye, Skybuck :)
BTW: Did you ha en to see any light flash/implosion in the sky ? I saw
something weird this night... like supernova implosion or something...
MitchAlsu quot; wrote in me age
On Jun 8, 6:10 pm, Skybuck Flying Windows7I
@DreamPC2006.com
This is probably why nvidia is trying to work on an arm chip that will
integrate into the gpu, hopefully the arm chip will be able to i ue
kernel
calls much faster.
I think it has more to do with Intel having its own on-die GPU, AMD
has its captured (ATI) on-die GPU, leaving nVidia out of the volume
game. It still has the ultra-high-end GPUs that su ort gammers.
Mitch You must
before you can post me ages.
To post a me age you must first
Please update your nickname on the
page before posting.
You do not have the permi ion required to post.
Andy Krazy Glew More optio Jun 11, 9:13 m
Newsgrou :
alt.comp.periphs.videocards.nvidia.programming, comp.arch
Andy \Krazy\ Glew a
@SPAM.comp-arch.net
Sat, 11 Jun 2011 18:13:28 -0700
Sat, Jun 11 2011 9:13 m
Subject:
Re: Cuda Q2: Branch Divergence Serialization (Threads/hardware stalls ?) Performance Impact ?
On 6/8/2011 3:32 PM, Skybuck Flying wrote:
For cuda it is claimed that threads will start to do other things as
it/they(?) schedules load requests from/for memory.
AFAIK this is not true. Any given thread/warp will stall until any of
its load requests are satisfied. The GPU will run other war ,
including other war on the same SIMD engine, but will not do anything
else with the warp that is blocked.
It has been proposed (google my presentation at Berkeley) to do things
like ru ing the other sides of diverged war when one side is blocked. But AFAIK that is NOT being done by any GPU yet.
My question is about " ranch divergence serializatio quot; (within a single
It is said that if threads within a warp diverge on branches that they
will be " erialized, so this would slow down the threads somewhat.
What exactly ha e ? How much of a performance penalty is it ? How many
cycles do branches takes ? And how many cycles would it take for worst case
scenerio ?
A warp is a group of 64 threads. A warp ru on a SIMD engine. The SIMD
engine is 16 execution units wide, each of which ru one thread within
the warp. I.e. executing all of the warp occupies at least 4 cycles.
(Pardon me if I get the numbers wrong: 4x16,=64, or maybe it's 8 wide,
or ...)
The key feature of GPU style architectures is that there is only 1
shared i truction fetch and decode for all (a) 16 threads executing on
a SIMD engine at any time, (b) for the entire 64 threads of a warp.
This works well as long as all ofthe threads are executing the same
i truction, i.e. at the same point in control flow.
But, if there is an IF tatement, executed by all of the threads, but
if some of the threads go down the THEN path, and some go down the ELSE
path, then you have divergence. Typically a bitmask for the threads
that have gone down the else path is pushed on the stack, and the
threads that are executing the THEN path execute. The execution units
for the threads that are on the ELSE path are disabled, but are not
currently used for anything else (although I and others have proposed
how to do that).
Simply, the THEN threads execute under mask. When they come to an
i truction that is marked as the ELSE (and on some GPUs there is
literally an ELSE i truction, or at least a bitfield), the mask of THEN
threads is swa ed with the mask of ELSE threads at the tyop of the
stack. And then ELSE threads then execute, while the THEN threads are
masked off.
If there are nested IF/THEN/ELSEes the mask is pushed deeper on the stack.
It doe 't nece arily cost all that much. Divergent branches execute
just a bit slower than branches that are guaranteed not to diverge.
But, there is a big o ortunity cost. Some fraction of the SIMD engine
is disabled, and does not execute.
Worst case: complete divergence. Many GPUs do not su ort indirect
branches, but if one did you could imagine: witch( i ) { case 0: ... break; ... case 63: ... break; }
i.e. you can imagine all of the threads within a warp going to a
different indirect branch target / case label. Which would mean that
you would execute them all one at a time, using only one of the 16
lanes, or only 1 or the 64 threads in a warp, at a time.
I.e. worst case you are 64 times slower. Because 63/64s of the hardware
is going idle.
You can, of course, create imilar divergent control flow with IF
statements. Or even with WHILE loo , indefinite iteratio , executing a
different length on each thread. You must
before you can post me ages.
To post a me age you must first
Please update your nickname on the
page before posting.
You do not have the permi ion required to post.
Skybuck Flying More optio Jun 12, 3:16 am
Newsgrou :
alt.comp.periphs.videocards.nvidia.programming, comp.arch
Skybuck Flying Windows7I
@DreamPC2006.com
Sun, 12 Jun 2011 09:16:20 +0200
Sun, Jun 12 2011 3:16 am
Subject:
Re: Cuda Q2: Branch Divergence Serialization (Threads/hardware stalls ?) Performance Impact ?
All of my questio are pretty well explained in:
CUDA C programming guide (Which came with CUDA Toolkit 4.0)
The model behind CUDA so far is:
Which mea :
Single I truction Multiple Threads.
Each thread has it's own i truction pointers and it's own registers
(register states).
A thread is part of a warp.
A warp co ists out of 32 threads.
Each thread can i rinciple logically follow it's own path, this includes
paths/branches based on data and indexes, like the build-in indexes, pretty
much anything.
How the hardware exactly works remai secret, however I su ect the
hardware examines the i truction pointers of all threads.
If the hardware detects that the threads are all or most of them are
pointing to the same i truction, then I su ect that i truction gets
executed once if po ible,
or perha it's execute in parallel for different data items... but there is
probably some kind of efficiency going on deep in the hardware.
Perha it can execute c = a * b for all threads just once if c, a and b are
a shared location, it makes no se e to calculate that 32 times so perha it can then
calculate that just once... co tant calculatio like c = 4 * 5 are
probably pre-calculated.
So why it's exactly called " ingle i truction multiple thread is a bit
mysterious. Perha it's simply a form of sharing " inary i truction
codes/ ace so that they same
program does not have to be copied hundreds of times, which makes se e.
Only the i truction pointers, and the data items are unique and duplicated.
Anyway, the hardware tries to execute the threads in a warp in parallel, if
it can't do that for some reason then some of threads are serialized, it
might then still
execute some of those perha in parallel or maybe not at all, that's not
entirely clear, but I think it can do that.
After all the serialized divergent branches are executed it comes back
together at a " arallel continuation point where all the threads are
executing in parallel again.
It also achieves this by stalling threads which have to wait on the other
threads within the warp. So it automatically serializes (de-parallizing) and
synchronizes (re-parallizing) the threads.
When an entire warp gets stalled for some reason it could switch to another
warp which might be ready to run and try to execute that.
Stalls can ha en because of serializing, memory acce es, and registers
being used in previous and current i tructio (write/read dependancies)
and also synchronization i tructio .
The weirdne for the programmer starts with trying to achieve maximum
performance for stall situatio .
There seem to be two ways to maximum performance:
1. Maximum the number of threads for a thread block.
2. Maximum the number of thread blocks.
A thread block is not the same as a warp.
A thread block can co ists out of war .
So a thread block ecifies how many threads there are in the block. There
could be a certain maximum, say 512 or 1024 or just 2 or 10 or any number.
The warp schedular/the cuda system will divide the number of threads in the
thread block by the warp size.
The warp size is fixed at 32 for all gpu's.
So the number of " o ible war for a thread block is:
Threads in thread block / warp size=32 = number of war .
So at first glance it would seem smart for the programmer to make the number
of threads in a thread block as high as po ible, so that the number of
war become as high as po ible.
But there is a second weird option:
The programmer could also choose to maximum the number of blocks.
To me this more or le seems the same thing.
Su ose a thread block has 32 threads which is exactly the warp size then
multiple of these blocks could be made/i ued.
As far as I can tell the warp schedular/gpu system will still switch from
stalled war to other war in other blocks ?!?
(Or perha not, I am not sure yet)
^ This is a bit vague still...
So this seems a bit weird... why give the programmer two different
optio /po ibilities/setu which more or le do the same thing ?
What's the difference between:
1. 1024 threads in a single block
2. 1024/32 blocks of each 32 threads.
One po ible a wer might be that can be distributed over multiple
multi-proce ing unit quot; (which is the basic piece of hardware/core i ide a
While a single thread block can only reside on a single multi-proce ing
unit (?!).
So perha that's the a wer.
The programmer or program/a lication will have to examine the hardware, it
will have to look at how many multi-proce ing unit quot; are available.
And then it will have to distribute it's workload over multi-proce ing
unit quot;.
However the trick is to keep " talled multi-proce ing units busy as well.
So to be able to do that a single thread block must have multiple war , in
case a single warp gets stalled.
(It's also wastefull if the number of threads is not equal to a multiple of
warp size, since then a few threads will do nothing).
The programming guide has more information about how much cycles it takes to
execute the warp in it's entirety.
It has to do something with how long it takes to execute serialized
i tructio . Each serialized i truction could take for example 4 clock
cycles, it depends a bit on the i truction
clock cycle cost.
Cheaper gpu's only execute one i truction per clock cycle per multi
proce or unit, expe ive gpu's can execute two i tructio or even more
but this also makes latency hiding
more difficult because it can execute more/faster it most also have more
data/threads to switch to when latency ha e , but that is logical in a
way... more proce ing power so it can handle more data, as long as it also
has more memory ofcourse.
When wra still because of memory requests/latency it is claimed to be a
cost of 600 to 800 clock cycles.
The question is how to distribute. There seems to be no clear a wer.
There is a " readsheet calculator available which is for excell, this is
kinda shitty because I do not have excell i talled, I don't really need MS
Office, but now I must i tall it just
for this one little tool. Anyway the a wer giving is to experiment with
this/to experiment with settings of kernel execution.
In the future the a wer might change a bit of gpu's can actually execute
multiple a licatio at the same time, like cpu's do/can... I am not yet
sure if gpu's can actually do that, and how it would impact the a wer.
For now my advice would be simple:
1. Try to maximum the number of overal threads for the
a lication/kernel/algorithm/data first, so maximize the parallism of it,
put this number in a variable called:
TotalThreads
2. Then query the hardware/gpu/device and figure out how many
multi-proce ing unit quot; it has, then simply distribute the total ammount of
threads over the mpu's:
ThreadsPerMPU = TotalThreads div MPUCount;
For example:
TotalThreads = 2000;
MPUCount = 17; // unrealistic number but it's the idea that count.
ThreadsPerMPU = 2000 div 17 = 117 threads per mpu.
However there is also a remainder so that can be calculated as well:
ThreadsForLastMPY = 2000 mod 17 = 11 threads for last mpu.
However there is no last mpu, there are only 17 and not 18.
So the a wer is probably to ceil the 117, plus a little bit to 118 and
then recalculate how many threads there would be to get an idea
of wasted threads (ceiled threads * mpu count):
118 * 17 = 2006 threads, 6 threads would be wasted, not so bad in this
example. I gue the maximum number of threads wasted is 31 since warp size
is 32 so it's (warp size-1).
However this a umption of waste only holds if the number of mpu's
multiplied by the warp size is actually lower then the number of total
threads, otherwise there will ofcourse
be waste.
The ammount of threads the system can handle is mpu count * warp size = 17 *
32 = 544.
So if there would be le than 544 threads in total, then some threads on
the war would so nothing.
However there is more to it then meets they eye perha .
Let's go back to the 117 threads or 118 threads per mpu.
This must now be divided by the warp size to get an idea of the last warp
being not perfectly 32.
117 div 32 = 3,656
117 mod 32 = 21 threads would be wasted on last warp.
I am now not sure what cuda does... would it allocate 3 or 4 war ? Perha 4 but it could also be 3 so I am not sure.
Let's see what ha e for 118:
118 div 32 = 3,687
118 mod 32 = 22 threads would be wasted on last warp but at least it fits on
all mpu's ;)
At least there will be 3 war which will offer some latency hiding but
probably not a lot... unle the kernels execute a lot of i tructio before stalling again.
So the conclusion is pretty simple/easy:
CUDA needs a lot of threads to perform well, or it needs a lot of
i tructio to perform well.
The more threads the more memory it needs, so graphics cards will need to
get a lot more memory, but the memory system must also become faster so more
bandwidth required.
Generally it seems the more bandwidth the hotter the card, is there a
logical correlation/explanation ?!? Also the higher the bandwidth the higher
the price it seems, but this
could be artificial pricing.
The last question remai :
What are grids ?!? I am not exactly sure, but perha this comes into play
when there are multiple devices or so... but as far as I can tell kernels
can only be executed
on a single device... so I kinda forgot what grids are for... they at least
offer more subdividing/distribution po ibilities.
For now it escapes me what the usefullne is of grids... I think it's
coming back to me... it might have to do with global memory only, or
non-shared-memory.
Blocks can share memory between each other. Grids ca ot.
So grids are probably a further division for adding computation power at the
cost of no-sharing between grids themselfes, except via the slower global
... You must
before you can post me ages.
To post a me age you must first
Please update your nickname on the
page before posting.
You do not have the permi ion required to post.
Skybuck Flying More optio Jun 13, 11:35 m
Newsgrou :
alt.comp.periphs.videocards.nvidia.programming, comp.arch
Skybuck Flying Windows7I
@DreamPC2006.com
Tue, 14 Jun 2011 05:35:08 +0200
Mon, Jun 13 2011 11:35 m
Subject:
Re: Cuda Q2: Branch Divergence Serialization (Threads/hardware stalls ?) Performance Impact ?
Hmm first of all there are further problems with limiting the ammount of
threads per block to the max thread per block limitation.
Second of all somebody wrote that the memory threads per block are a igned
the le registers available for the threads which is logically since they
need to share/distribute the available registers among each other.
So the registers used/available also becomes part of the equatio quot;.
So if a kernel uses lot's of registers then it might be smarter to reduce
the number of threads per block.
I wonder what the algorithm is for the read sheet calculator, perha it
uses a solver.
Bye, Skybuck. You must
before you can post me ages.
To post a me age you must first
Please update your nickname on the
page before posting.
You do not have the permi ion required to post.
End of me ages -
2011 Google图纸中cl什么意思
悬赏分：0
解决时间：2011-3-15 16:28
提问者：
最佳***
CL Centerline 中心线
ALL WELDS CONTINUOUS UNLESS OTHERWISE STATED. 未注焊缝均为连续焊
ALL WELDS 3mm FILLET UNLESS OTHERWISE STATED 未注焊角高3mm.
ALL UNSPECIFIED RADI - R3 未注圆角R3
REMOVE ALL BURRS AND SHARP EDGES 所有尖角/棱角倒角并去毛
11 TOTAL COILS APROX.9 WO***NG COILS APROX.RIGHT HAND WOUND ONLY,END COILS SQUARE TO TOUCH.
总圈数约11圈；工作圈数约9圈；右旋；弹簧的端部磨平以便于接触.(此为弹簧技术说明)
CHANNEL 槽钢
RSA 708 角钢 70X70X8
M30X1.5 pitch M30X1.5的锥螺纹
Tackweld 点焊
OD 1/4" outside dime ion 1/4"的缩写 外径直1/4"
75 CRS 尺寸为75 材质为冷轧钢板
410 OPENING REF 410 开口参考尺寸
40 REF 尺寸为40,参考值
2.5" BSP 2.5” 圆锥管螺纹
2.5" BSPT HEXAGON 2.5” 六角圆锥管螺纹(即对丝)
30x2.5 FLAT BAR 30X2.5 扁钢
TYP 2 POSNS 2处
FEMALE: 内扣(母扣)
MALE: 外扣(公扣)
偏心轴 eccentric shaft
销轴 PIN
开口销 COTTER PIN
螺杆 screw
轴承 axletree
挡圈 closing ring
弹性挡圈 circlip
弹簧 SPRING
紧定螺钉 SET SCREW
圆螺母 ROUND NUT
平键 FLAT KEY
圆螺母 ROUND NUT
六角螺栓 HEX HD BOLT
无扣长 non-buckle longth
平垫圈 FLAT WASHER
螺母 FULL NYLOCK NUT
吊环螺钉 LIFTING EYE BOLT
内六角螺钉 SOCKET HEAD CAP SCREW
六角螺钉 HEX HD SETSCREW
轴承隔套 distance sleeve of axletree
深沟球轴承 DEEP GROOVE BALL BEARING
开槽盘头螺钉 SLOTTED PAN HEAD SCREW
圆锥滚子轴承 TAPERED ROLLER BEARING
推力球轴承THRUST BALL BEARING
弹簧垫圈 SINGLE COIL SPRING WASHER
缩写 全称 翻译
ACCESS Acce ory 附件
ADJ Adjustable,Adjust 调整
ADPT Adapter 使适应
ADV Advance 提前
AL Aluminum 铝
ALLOW Allowance 允许
ALT Alternate 改变
ALY Alloy 合金
AMT Amout 数量
ANL A eal 锻炼
ANSL Amer Natl Stds I titute
APPROX A roximate 大约
ASME Amer Society of Mech Engrs
ASSEM A emble 装配
ASSY A embly 装配
AUTH Authorized 授权的
AUTO Automatic 自动的
AUX Auxiliary 辅助的
***G Average 平均
AWG American Wire Gauge
BC Bolt Circle 螺栓圆周
BET Between 之间
BEV Bevel 斜角
BHN Brinell Hardne Number布氏硬度值
BLK Blank ,Block 空白
B/NM Bill of Material 材料费
BOT Bottom 底部
BP or B/P Blueprint 蓝图
BRG Bearing 轴承
BRK Break 破裂
BRKT Bracket 支架
BRO Broach 钻孔
BRS Bra 黄铜
BRZ Bronze 青铜
B＆S Brown＆Shape 棕色＆形状
BSC Basic 基本的
BUSH Bushing 套管
BWG Birmingham Wire Gauge
C TO C Center-to-Center 中心到中心
CAD Computer-Aided Drafting 电脑辅助设计
CAM Computer-Aided Mfg
CAP Capacity 容量
CAP SCR Cap Screw 螺帽
CARB Carburize 使渗碳
CBORE Counterbore 扩孔
CCW Counter Clockwise 逆时针
CDRILL Counerdrill
CDS Cold-Drawn Steel
缩写 全称 翻译
EFF Effective 有效的
ENCL Enclose,Enclosure 附上
ENG Engine 引擎
ENGR Engineer 工程师
ENGRG Engineering 工程学
EQLSP Equally Spaced 等距
EQUIV Equivalent 相等
EST Estimate 估计
EX Extra 额外
EXH Exhaust 消耗
EXP Experimental 实验性的
EXT Exe ion,External 范围,外部
FAB Fabricate 伪造
FAO Finish All Over
FDRY Foundry 铸造
FIG Figure 数据
FIL Fillet,fillister 带子
FIM Full Indicator Movement
FIN Finish
FLX Fixture 结构
FLX Floor.Fluid,Flush 基地,液体,冲洗
FLEX Flexible 易弯曲的
FLG Flange 边缘
FORG Forging 锻炼
FR Frame,Front 边框
FIG Fitting 装置
FURN Furnish 提供
FWD Forward 向前
GA Gage,Gauge 测量
GALV Galvanized 电镀
GR Grade 等级
GRD Grind 磨碎
GRV Groove 凹槽
GSKT Gasket 垫圈
H＆G Harden and Grind 加硬和磨碎
HD Head 主要的
HDL Handle 处理
HDLS Headle 无领导的
HDN Harden 使硬化
HDW Hardware 硬件
HEX Hexagon 六边形
HGR Hanger 衣架
HGT Height 高度
HOR Horizontal 水平的
HRS Hot-Rolled Steel
HSG Housing 外罩
HT TR Heat Treal
缩写 全称 翻译
NTS Not to Scale
OA Over All 所有
OBS O otetc
OC On Center
OD Outside Diameter 外直径
OPP O osite 对立
OPTL Optional 可选择的
OR Outside Radius 外半径
ORIG Original 初始的
PAT. Patent 专利
PATT Pattern 形式
PC Piece,Pitch Circle 件，节距圆
PCH Punch 打孔
PD Pitch Diameter
PERF Perforate 打孔
PERM Permanent 永久的
PERP Perpendicular 垂直的
PFD Preferred 首选的
PKG Package,Packing 包装
PL Parting Line,Places,Plate
PNEU Pncumatic
PNL Panel 面板
POL Polish 磨光
POS Position,Postive 位置
PR Pair 对立
PRI Primary 基本的
PROC Proce 程序
PROD Product,Production 产品，产量
PSI Pounds per Square Inch
PT Part,Point 零件，点
QTR Quarter 四份之一
QTY Quantity 数量
QUAL Quality 质量
R Radius 半径
RA Rockwell Harden,A-Scale
RB Rockwell Harden,B-Scale
RC Rockwell Harden,C-Scale
RECD Received 巳收到的
RECT Rectangle 长方形
REF Reference 相关的
REINF Reinforce 增强
REL Release,Relief 释放，缓解
REM Remove 移除
REQD Requird 有需要
REE Retainer,Return
REV Reverse,Revision,Revolution
RFS Regardle of Feature Size
RGH Rough 粗糙的
RH Right Hand 右手
RIV Rivet 起皱
RM Ream 扩展
RND Round 周围
RPM Revolutio per Minute
RPW Resistance Projection Weld
SAE Society of Automotive Engrs
SCH Schedule 进度表
缩写 全称 翻译
CFS Cold-Finished Steel
CH Case Harden
CHAM Chamfer 斜面
CHAN Cha el 渠道
CHG Change 改变
CHK Check 核查
CI Cast Iron 铸铁
CIR Circle, Circular 圆周
CIRC Circumference 圆周
CL Centerline 中心线
CLP Clamp 夹子
CNC Computer Numerical Control 电脑数值控制
COMB Combination 联合
COML Commercial 商业的
CONC Concentric 同中心的
CONN Co ect,Co ector 连接器
COV Cover 盖子
CPLG Coupling 联结
CQ Commercial Quality 商业等级钢
CRS Cold Stds A ociation
CRT Cathode Ray Tube 阴级射线管
CS Cast Steel 铸铁
CSA Canadian Stds A ociation
CSK Countersink 埋头孔
CSTG Casting 铸件
CTR Center 中心
CU Cubic 立方米
CW Clockwise 顺时针
CYL Cylinder,Cylindrical 柱面
DBL Double 双倍
DEC Decimal 小数
DEG Degree 摄氏度
DET Detail 详情
DEV Develop 发展
DFT Draft 草稿
DIA Diameter 直径
DIM Dime ion 尺寸
DIST Distance 距离
DN Down 向下
DP Deep,Diametral Pitch 深度,径节
DR Drill,Drill Rod 钻孔
DSGN Design 设计
DVTL Dovetail 吻合
DWG Drawing 图纸
DWL Dowel 木钉
DWN Drawn 拔出
EA Each 每个
ECC Eccentric 古怪
缩写 全称 翻译
HVY Heavy 重量
HYD Hydraulic 水压
ID I ide Diameter 内部直径
IDENT Identification 鉴定
ILLUS Illustration 说明
IN Inch 英寸
INCL Include,Including 包括
INCR Increase 增加
INFO Information 信息
INSP I ect 检查
INSTL I tall ***
INST I truct,I trument 指示,工具
INT Interior,Internal,Intersect 内部的,内在的,交叉
IR I ide Radius 内部半径
ISO Internal Stds Organization 国际标准化组织
JCT Junction 连结
JNT Journal 杂志
JT Joint 连接
K Key 关键
KNRL Knurl 硬节
KST Keyseat
KWY Keyway 键沟
LB Pound 英镑
LBL Label 标签
LG Length,Long 长度
LH Left Hand 左手
LMC Least Material Condition
LOC Locate 位于
LT Light 光
LTR Letter 信
LUB Lubricate 润滑
MACH Machine 机器
MAINT Maintenance 维护
MATL Material 材料
MAX Maximum 最大
MECH Mechanical,Mechanism 机械
MED Medium 媒介
MFG Manufacturing 制造业
MI Malleable Iron 可锻造的铁
MIN Minimum, Minute 最小，秒
MISC Miscellaneous 混杂的
MM Millimeter 毫米
MMC Max Material Condition
MS Machine Steel
MTG Mouting 装备
MULT Multiple 倍数
MWG Music Wire Gagug
NA Not A licable 不可应用的
NATL National 国内的
NC Numerical Control 数字电脑控制
NEG Negative 忽略的
NO. Number 号码
NOM Nominal 名义上的
NPSM Natl Pipe Straight Mech
NPT Natl Pipe Tapered
缩写 全称 翻译
SCR Screw 螺丝
SEC Second 秒
SECT Section 部分
SEP Separate 独立
SEQ Sequence 顺序
SER Serial,Series 系列
SERR Serrate 锯齿状
SF Spotface
SFT Shaft 轴
SGL Single 单个
SH Sheet 纸
SI Intl System of Units
SL Slide 使滑动
SLV Sleeve 袖子
SOC Socket 插座
SP Space,Spaced,Spare 空间
SPL Special 特别
SPEC Specification 规格
SPG Spring 跳
SPHER Spherical 球体
SPRKT Sprocket 链轮齿
SQ Square 平方
SST Stainle Steel 纯铁
STD Standard 标准
STK Stock 存货
STL Steel 铁
STR Straight,Strip 直的
SUB Su titute 替代物
SUP Su ly,Su ort 供应
SURF Surface 表面
SYM Symmetrical 对称的
SYS System 系统
T Teeth,Tooth 牙齿
TECH Technical 技术
TEMP Template,Temporary模板，暂时的
THD Thread 线
THK Thick 厚的
TOL Tolerance 公差
TOT Total 总计
TPF Taper per Foot
TPI Taper per In,Threads per Inch
TPR Taper 锥形
TS Tool Steel
TYP Typical 典型
UNC Unified Natl Coarse
UNEF Unified Natl Extra Fine
UNF Unified Natl Fine
UNIV Universal 普遍
VAR Variable 变量
VERT Vertical 垂直的
VOL Volume 音量
VS Versus 与．．相对
W Wide,Width 宽度
WASH Washer 洗衣机
WDF Woodruff 车叶草
WI Wrought Iron 熟铁
WT Weight 重量
SAE Extra fine 美国汽车工程师协会的超细牙螺纹 例：1/2-28 SAE Extra fine
SAE Reg 美国汽车工程师协会的标准系列螺纹 例：1/2-20 SAE Reg
SAE-LT 美国汽车工程师协会的圆锥外螺纹 例：1/2-28 SAE-LT
我的是机械类的图纸
分享给你的朋友吧：
对我有帮助
回答时间：2011-3-15 16:25
回答者：
来自团队
采纳率：19%
擅长领域：
参加的活动：
暂时没有参加的活动
提问者对于***的评价：
相关内容
2009-9-10
2007-9-13
2011-3-14
2011-1-11
2011-1-27
分享到：
推广链接
用户名：
记住我的登录状态
2011 BaiduMobile:13530901933
MSN:shizhenghai@hotmail.com
高级DBA,OCM大师,Oracle授权讲师
切换风格
选择页面布局
两栏左侧导航（缺省）
两栏右侧导航
选择配色方案
纯净蓝灰（缺省）
点击带有"..."标记的栏目可以展开/收拢相应的栏目
展开所有
收拢所有
订阅我的Blog
博客日历
八月 2011
31 文章归档...
最新发表...
最多阅读文章...
(48474 次)
(48469 次)
(48405 次)
(48344 次)
(48212 次)
(48169 次)
(48144 次)
(48143 次)
(48071 次)
(48066 次)
博客统计...
总文章数:
总评论数:
总引用数:
总浏览数:
网站链接...
Powered by:
Blog Provider:
Designed by:
===========================================================
什么是并行查询及其原理
===========================================================
作者: shiyihai(http://shiyihai.itpub.net)
发表于:2006.05.02 17:22
出处：http://shiyihai.itpub.net/post/2333/286586
---------------------------------------------------------------
在OLAP环境，以利用多的CPU和内存资源来加速处理数据，也即oracle的并行查询。单个CPU同一时刻只能服务一个进程，如果有多个CPU，提高CPU利用律，就可以同时运行多个进程。也就是原来单个进程处理的变成多个进程并行处理加速执行时间。并行执行只是在全表处理或者分区及在分区表中执行本地索引时用到。下面情况会用到并行查询：
全表扫描、 rebuild index、update (全表或分区表)、i ert的并行子查询、本地索引使用、批量插入，象SQLLDR、创建临时表
比如我们执行
select /*+ parallel(c1 ,2) */
from customers c1
order by ...proce a proce b
fetch rows from fetch rows from
customers customers
proce c proce d
sort rows(a-k) sort rows(l-z)
combine rows
return result set
这里我们看到这个进程分散成4个进程，排序中各负责a-k和l-z，这样就可以并行处理
我们在分区表中，也可以用一个并行从进程对应一个分区表如果你的并行度是3，那么你可能就比普通的执行速度提高3倍
注意在单CPU下，如果使用并行，那么就可能造成性能下降，而且也要设置合适的并行度
并行适合对于长时间运行的语句
在oltp可能并不适合使用并行处理，因为事务并发比较多，每个用户都要使用CPU，CPU的负载本来就比较高
所以并行处理还是比较适合olap中的批量导入,sqlldr,mis report和oltp中rebuild index。
1、看看并行选件是否***
SELECT * FROM V$OPTION
Parallel execution是不是TRUE
2、如果是TRUE，执行语句后查看
select * from V$pq_se tat;
如果Queries Parallelized0就说明是执行了并行
3、可以强制使用PARALLEL，和CPU数量无关，不过在单个CPU下使用并行没有什么好处
alter se ion force parallel query；
4、你是怎么知道语句没有使用PARALLEL?
如果你用EXPLAIN ，那么有两个脚本看执行计划
UTLXPLS.UTLXPLP前一个是看串行计划的，后一个才能看到并行计划，
如果你使用SET AUTOTRACE，那么你如果看到P-S，那么说明计划已经是并行的了。1.与并行查询有关的参数有哪些?
parallel_adaptive_multi_user boolean
启用或禁用一个自适应算法，旨在提高使用并行执行方式的多用户环境的性能。通过按系统负荷自
动降低请求的并行度，在启动查询时实现此功能。当 PARALLEL_AUTOMATIC_TUNING = TRUE 时，其效果最佳。
TRUE | FALSE 如果 PARALLEL_AUTOMATIC_TUNING = TRUE，则该值为 TRUE；否则为 FALSE
parallel_automatic_tuning boolean
如果设置为 TRUE，Oracle 将为控制并行执行的参数确定默认值。除了设置该参数外，你还必须为
系统中的表设置并行性。
TRUE | FALSE FALSE
parallel_execution_me age_size integer
指定并行执行 (并行查询、PDML、并行恢复和复制) 消息的大小。如果值大于 2048 或 4096，就需
要更大的共享池。如果 PARALLEL_AUTOMATIC_TUNING =TRUE，将在大存储池之外指定消息缓冲区。
2148 - 无穷大。 如果 PARALLEL_AUTOMATIC_TUNING 为 FALSE，通常值为 2148；如果
PARALLEL_AUTOMATIC_TUNING 为 TRUE ，则值为 4096 (根据操作系统而定)。
parallel_max_servers integer
指定一个例程的并行执行服务器或并行恢复进程的最大数量。如果需要，例程启动时分配的查询服
务器的数量将增加到该数量。
0 -256 由 CPU_COUNT, PARALLEL_AUTOMATIC_TUNING 和 PARALLEL_ADAPTIVE_MULTI_USER 确定
parallel_min_percent integer
指定并行执行要求的线程的最小百分比。设置该参数，可以确保并行执行在没有可用的恰当查询从
属时，会显示一个错误消息，并且该查询会因此而不予执行。
parallel_min_servers integer
指定为并行执行启动例程后，Oracle 创建的查询服务器进程的最小数量。
0 - PARALLEL_MAX_SERVERS。
parallel_threads_per_cpu integer
说明一个 CPU 在并行执行过程中可处理的进程或线程的数量，并优化并行自适应算法和负载均衡算
法。如果计算机在执行一个典型查询时有超负荷的迹象，应减小该数值
任何非零值。 根据操作系统而定 (通常为 2)
2.当前时刻有那些并行查询在跑?
14:13:46 SQL desc v$px_se ion
名称 是否为空? 类型
----------------------------------------- -------- ------------------
SADDR RAW(4)
SID NUMBER
SERIAL# NUMBER
QCSID NUMBER
QCSERIAL# NUMBER
QCINST_ID NUMBER
SERVER_GROUP NUMBER
SERVER_SET NUMBER
SERVER# NUMBER
DEGREE NUMBER
REQ_DEGREE NUMBER
3.怎么才能让查询有并行执行?
如果建表时指定了并行度,例:
CREATE TABLE LI2.PAR_T
a VARCHAR2 (5)
PARALLEL 5;
那么对该表做全表扫描时就会并行
14:26:05 SQL set autot on
14:26:11 SQL select * from par_t;
未选定行
已用时间: 00: 00: 00.02
Execution Plan
----------------------------------------------------------
0 SELECT STATEMENT Optimizer=CHOOSE (Cost=1 Card=82 Bytes=328)
1 0 TABLE ACCESS* (FULL) OF 'PAR_T' (Cost=1 Card=82 Bytes=328) :Q6000
1 PARALLEL_TO_SERIAL SELECT /*+ NO_EXPAND ROWID(A1) */ A1.A FRO
M PAR_T PX_GRANULE(0, BLOCK_RANGE,
如果该表没有指定并行度,可以在查询时用hint 实现,例:
select /*+ full(t) parallel(t,5) */ * from your_table t where ...;
4.为什么本该并行执行的查询没有并行执行呢?
系统的并行度由parallel_max_servers 决定,如果它的并行度为5.如果有一个并行度为5的查询在跑,那么系统在这条查询运行完成前是不能再跑并行查询的,该并行查询将会以非并行方式运行.
5如果有并行度低于系统最大并行数的查询在跑,那接下来的并行查询会怎么跑呢?
When you ecify parallel degree 4 oracle tries to allocate 4 producer slaves and 4 co umer slaves. The producers can feed any of the co umers.
If there are only 2 slaves available then we use these.
If there is only 1 slave available then we go serial
If there are none available then we use serial.
If parallel_min_percent is set then we error ora 12827 i tead of using a lower number of slaves or going serial
6.设定parallel_max_servers 多大为好?
在多CPU的环境中,一般把CPU-1或CPU的数量做个最大并行数,因为并行查询运行时还需要一个进程协调各并行进程.对于单CPU没什么好说的.
7.并行查询能提高系统的性能吗?
并行查询运行时,很容易会使机器运行在高负荷下,令系统对其它事务的处理时间大大加长.并行查询一般适合在非业务高峰值人工执行,并不适合在程序中指定运行并行查询.
PINNER:
并行不等于快速，仅仅是适合在数据仓库环境，低业务请求与低并发操作的时候
典型的OLTP系统，如果我们的系统，是绝对不允许并行查询出现的。
shiyihai
发表于:2006.05.02 17:22
::分类:
::阅读:(990次)
发表评论
在此添加评论
邮箱地址（可选）
个人主页（可选）
记住我？
验证码 奋斗！奋斗！ 再奋斗！
( Mon, 28 Jun 2010 16:07:49 +0800 )
Description:
? Struts1要求Action类继承一个抽象基类。Struts1的一个普遍问题是使用抽象类编程而不是接口。
? Struts 2 Action类可以实现一个Action接口，也可实现其他接口，使可选和定制的服务成为可能。Struts2提供一个ActionSu ort基类去实现常用的接口。Action接口不是必须的，任何有execute标识的POJO对象都可以用作Struts2的Action对象。
线程模式:
? Struts1 Action是单例模式并且必须是线程安全的，因为仅有Action的一个实例来处理所有的请求。单例策略限制了Struts1 Action能作的事，并且要在开发时特别小心。Action资源必须是线程安全的或同步的。
? Struts2 Action对象为每一个请求产生一个实例，因此没有线程安全问题。（实际上，servlet容器给每个请求产生许多可丢弃的对象，并且不会导致性能和垃圾回收问题）
Servlet 依赖:
? Struts1 Action 依赖于Servlet API ,因为当一个Action被调用时HttpServletRequest 和 HttpServletRe o e 被传递给execute方法。
? Struts 2 Action不依赖于容器，允许Action脱离容器单独被测试。如果需要，Struts2 Action仍然可以访问初始的request和re o e。但是，其他的元素减少或者消除了直接访问HttpServetRequest 和 HttpServletRe o e的必要性。
可测性:
? 测试Struts1 Action的一个主要问题是execute方法暴露了servlet API（这使得测试要依赖于容器）。一个第三方扩展－－Struts TestCase－－提供了一套Struts1的模拟对象（来进行测试）。
? Struts 2 Action可以通过初始化、设置属性、调用方法来测试，“依赖注入”支持也使测试更容易。
捕获输入:
? Struts1 使用ActionForm对象捕获输入。所有的ActionForm必须继承一个基类。因为其他JavaBean不能用作ActionForm，开发者经常创建多余的类捕获输入。动态Bean（DynaBea ）可以作为创建传统ActionForm的选择，但是，开发者可能是在重新描述(创建)已经存在的JavaBean（仍然会导致有冗余的javabean）。
? Struts 2直接使用Action属性作为输入属性，消除了对第二个输入对象的需求。输入属性可能是有自己(子)属性的rich对象类型。Action属性能够通过 web页面上的tagli 访问。Struts2也支持ActionForm模式。rich对象类型，包括业务对象，能够用作输入/输出对象。这种 ModelDriven 特性简化了taglib对POJO输入对象的引用。
表达式语言：
? Struts1 整合了JSTL，因此使用JSTL EL。这种EL有基本对象图遍历，但是对集合和索引属性的支持很弱。
? Struts2可以使用JSTL，但是也支持一个更强大和灵活的表达式语言－－"Object Graph Notation Language" (OGNL).
绑定值到页面（view）:
? Struts 1使用标准JSP机制把对象绑定到页面中来访问。
? Struts 2 使用 "ValueStack"技术，使taglib能够访问值而不需要把你的页面（view）和对象绑定起来。ValueStack策略允许通过一系列名称相同但类型不同的属性重用页面（view）。
类型转换：
? Struts 1 ActionForm 属性通常都是String类型。Struts1使用Commo -Beanutils进行类型转换。每个类一个转换器，对每一个实例来说是不可配置的。
? Struts2 使用OGNL进行类型转换。提供基本和常用对象的转换器。
校验：
? Struts 1支持在ActionForm的validate方法中手动校验，或者通过Commo Validator的扩展来校验。同一个类可以有不同的校验内容，但不能校验子对象。
? Struts2支持通过validate方法和XWork校验框架来进行校验。XWork校验框架使用为属性类类型定义的校验和内容校验，来支持chain校验子属性
Action执行的控制：
? Struts1支持每一个模块有单独的Request Proce ors（生命周期），但是模块中的所有Action必须共享相同的生命周期。
? Struts2支持通过拦截器堆栈（Interceptor Stacks）为每一个Action创建不同的生命周期。堆栈能够根据需要和不同的Action一起使用。
( Mon, 28 Jun 2010 15:14:38 +0800 )
Description: 第一是“贫穷” 贫穷不能等———因为一旦长时间的贫穷，你将习惯贫穷，到时不但无法突破自我，甚至会抹杀了自己的梦想，而庸庸碌碌无所作为的过一辈子…… 第二是“梦想” 梦想不能等———因为人生不同的阶段，会有不同的历练和想法，试想一个问题：如果你20岁时的梦想，在60岁的时候才得以实现，那会是什么样的一个情况？譬如说你20岁时的梦想是希望能买到一辆法拉利的跑车，然後到德国的无限速公路狂飙。你一直努力工作，好不容易到60岁了，总算买得起跑车了，但要实现年轻时的梦想，恐怕也是心有余而力不足吧…… 第三是“家人” 家人不能等，或许我们现在还年轻，未来有很多的时间可以让我们摸索、打拼 ,但是家人———我们的父母，他们有吗? 他们还有很多的时间等我们成功吗? 还有更多的时间等我们赚到大钱，让他们过好日子吗？让他们以我们为荣……
( Mon, 28 Jun 2010 15:14:07 +0800 )
Description:
1、总结自己一天任务的完成情况 最好的方式是写工作日志，把自己今天完成了什么事情，遇见了什么问题都记录下来，日后翻看好处多多
2、考虑自己明天应该做的主要工作 把明天要做的事情列出来，并按照优先级排列，第二天应该把自己效率最高的时间分配给最重要的工作
3、考虑自己一天工作中失误的地方，并想出避免下一次再犯的方法 出错不要紧，最重要的是不要重复犯相同的错误，那是愚蠢
4、考虑自己一天工作完成的质量和效率能否还能提高 一天只提高1%，365天你的效率就能提高多少倍你知道吗？ (1+0.01)^365 = 37 倍
5、看一个有用的新闻网站或读一张有用的报纸，了解业界动态 闭门造车是不行的，了解一下别人都在做什么，对自己能带来很多启示
6、记住一位同事的名字及其特点 你认识公司的所有同事吗？你了解他们吗？
7、清理自己的代码 今天完成的代码，把中间的调试信息，测试代码清理掉，按照编码风格整理好，注释都写好了吗？
8、清理自己的桌面 当日事当日毕，保持清洁干劲的桌面才能让你工作时不分心，程序员特别要把电脑的桌面清理干净
1、向你的老板汇报一次工作 让你的老板知道你在做什么，这很重要。可以口头、书面、邮件，看你老板的工作方式而定
2、进行一次自我总结（非正式） 这周之内自己表现得怎么样？该加分还是扣分？
3、制定下周计划 把下周要做的事情列出来，一样要分清楚优先级
4、整理自己的文件夹、书柜和电脑文件 把桌面以外的地方也要清理干净，电脑的文件夹，收到的邮件，把过时的垃圾全部清理掉
5、与一个非公司的朋友沟通 它山之石，可以攻玉
6、看一本杂志 找一本适合自己的专业杂志
7、纠正自己或同事一个细节上的不正确做法 《细节决定成败》看过了吗？没看过强烈建议先看看
1、至少和一个同事一起吃饭或喝茶 不光了解自己工作伙伴的工作，还要了解他们的生活
2、自我考核一次 相对正式地考核自己一下，你对得起这个月的工资吗？
3、对你的同事考核一次 你的同事表现怎么样？哪些人值得学习，哪些人需要帮助？
3、制定下月的计划，确定下月的工作重点
4、总结自己工作质量改进状况 自己的质量提高了多少？
5、有针对性地对一项工作指标做深入地分析并得出改进的方案 可以是对自己的，也可以是对公司的，一定要深入地分析后拿出自己的观点来。要想在老板面前说得上话，做的成事，工作上功夫要做足。
6、与老板沟通一次 最好是面对面地沟通，好好表现一下自己，虚心听取老板的意见，更重要的是要了解老板当前关心的重点
1、年终总结 每个公司都会做的事情，但你真正认真地总结过自己吗？
2、兑现给自己、给家人的承诺 给老婆、儿子的新年礼物买了没有？给自己的呢？
3、下年度工作规划 好好想想自己明年的发展目标，争取升职/加薪、跳槽还是自己出来干？
4、掌握一项新技术 至少是一项，作为程序员一年要是一项新技术都学不到手，那就一定会被淘汰。 掌握可不是看本书就行的，要真正懂得应用，最好你能够写一篇教程发表到你的blog
5、推出一种新产品 可以是一个真正的产品，也可以只是一个类库，只要是你创造的东西就行，让别人使用它，也为世界作点贡献。当然如果真的很有价值，收点注册费也是应该的
6、与父母团聚一次 常回家看看，常回家看看
( Sat, 17 Apr 2010 17:14:55 +0800 )
Description:
在网上翻阅了好多资料，好多代码还是很有用的，但是不完整，不符合我目前的需要
而且文档也不够完整，因此自己就整理了一下。
ort java.util.Calendar;
ort java.util.Date;
ort java.util.GregorianCalendar;
* Title: 周计算类，星期一为一周的开始，星期日为一周的结束/ gt;
* Description: 在两年的交接地带还有疑问。/ gt;
* 比如2006-12-29到2009-01-04，属于2008年的最后一周，/ gt;
* 2009-01-05位2009年第一周的开始。/ gt;
* db2种的week_iso也是这样计算的/ gt;
* Copyright: Copyright (c) 2006/ gt;
* DateTime: 2006-4-11 23:36:39/ gt;
* @author gumpgz
* @version 1.0
public cla WeekUtil {
* 取得当前日期是多少周
* @param date
* @return
public static int getWeekOfYear(Date date) {
Calendar c = new GregorianCalendar();
c.setFirstDayOfWeek(Calendar.MONDAY);
c.setMinimalDaysInFirstWeek(7);
c.setTime (date);
return c.get(Calendar.WEEK_OF_YEAR);
* 得到某一年周的总数
* @param year
* @return
public static int getMaxWeekNumOfYear(int year) {
Calendar c = new GregorianCalendar();
c.set(year, Calendar.DECEMBER, 31, 23, 59, 59);
return getWeekOfYear(c.getTime());
* 得到某年某周的第一天
* @param year
* @param week
* @return
public static Date getFirstDayOfWeek(int year, int week) {
Calendar c = new GregorianCalendar();
c.set(Calendar.YEAR, year);
c.set (Calendar.MONTH, Calendar.JANUARY);
c.set(Calendar.DATE, 1);
Calendar cal = (GregorianCalendar) c.clone();
cal.add(Calendar.DATE, week * 7);
return getFirstDayOfWeek(cal.getTime ());
* 得到某年某周的最后一天
* @param year
* @param week
* @return
public static Date getLastDayOfWeek(int year, int week) {
Calendar c = new GregorianCalendar();
c.set(Calendar.YEAR, year);
c.set(Calendar.MONTH, Calendar.JANUARY);
c.set(Calendar.DATE, 1);
Calendar cal = (GregorianCalendar) c.clone();
cal.add(Calendar.DATE , week * 7);
return getLastDayOfWeek(cal.getTime());
* 取得当前日期所在周的第一天
* @param date
* @return
public static Date getFirstDayOfWeek(Date date) {
Calendar c = new GregorianCalendar();
c.setFirstDayOfWeek(Calendar.MONDAY);
c.setTime(date);
c.set(Calendar.DAY_OF_WEEK, c.getFirstDayOfWeek()); // Monday
return c.getTime ();
* 取得当前日期所在周的最后一天
* @param date
* @return
public static Date getLastDayOfWeek(Date date) {
Calendar c = new GregorianCalendar();
c.setFirstDayOfWeek(Calendar.MONDAY);
c.setTime(date);
c.set(Calendar.DAY_OF_WEEK, c.getFirstDayOfWeek() + 6); // Sunday
return c.getTime();
public static void main(String[] args) {
int year = 2006;
int week = 1;
// 以2006-01-02位例
Calendar c = new GregorianCalendar();
c.set(2006, Calendar.JANUARY, 2);
Date d = c.getTime();
System.out.println("current date = " + d);
System.out.println("getWeekOfYear = " + getWeekOfYear(d));
System.out.println("getMaxWeekNumOfYear = " + getMaxWeekNumOfYear(year));
System.out.println("getFirstDayOfWeek = " + getFirstDayOfWeek(year, week));
System.out.println("getLastDayOfWeek = " + getLastDayOfWeek(year, week));
System.out.println ("getFirstDayOfWeek = " + getFirstDayOfWeek(d));
System.out.println("getLastDayOfWeek = " + getLastDayOfWeek(d));
} 本文来自CSDN博客，转载请标明出处：
( Wed, 24 Mar 2010 18:06:47 +0800 )
Description:
学习maven的使用，看到一篇很实用的入门教程(菜鸟级入门) 一、前言
早就知道maven 在java 项目的管理方面名声显赫，于是就想着学习掌握之，于是查阅了大量文档。发现这些文档的作者都是java 的大腕，大多都是站在掌握了一定maven 基础的角度上进行介绍，让我这初学者看的云里雾里不知所云。于是又去查看maven 的官方网站，总算是有所了解，但一旦动手实际操作却又雾里看花。唉，没办法，就只有一遍一遍的动手尝试，经过种
种磨难总算是有一点眉目了。现在就将我的经验写出来，一来避免将来遗忘，二来也给和我一样的菜鸟们提供一点点的方便。呵呵。本文的主题在于实用操作，个中原理还是麻烦大家去查一下java大腕们的文章吧。这里推荐两篇文章：
Maven 2.0:编译、测试、部署、运行
http://www.ideagrace.com/html/doc/2006/06/14/00847.html
Maven2 的新特性
http://www-128.ibm.com/developerworks/cn/ope ource/os-maven2/index.html
二、maven2***
1、首先去官方网站下载之：http://maven.apache.org/download.html，我选择的是截至目前最新版本maven2.0.4版本
2、设置环境变量：Maven2下载完后，我将其解压到我的计算机的d:\maven204下，目录结构如下：
|--Maven204
|-- bin
|-- conf
|-- core
|-- lib
|-- local
环境变量：（操作系统windows2003）
我 的电脑----属性----高级----环境变量，点击“系统变量”下的新建，输入：变量名 M***EN_HOME; 变量值d:\Maven204，在系统变量列表中找到系统变量path，打开之，在变量值中追加”;%M***EN_HOME%\bin”，至此环境变量设 置完毕。
检查一下是否已经完成***，打开dos窗口，输入mvn –v，如果出现以下信息则表示maven2已经***成功：
X：〉mvn –v
Maven Version 2.0.4
我已经说得够详细了，还不行？那我只能说你比我还菜。
三、用maven2创建第一个java工程
1、选择一个根目录，我的java工作目录是D:\ecli e\work ace
2、打开dos窗口采用cd命令进入D:\ecli e\work ace目录下
3、输入下列指令
D:\ecli e\work acemvn archetype:create -DgroupId=com.efn -DartifactId=study
指令执行完毕会出现如下的目录结构：
|-- pom.xml
`-- src
|-- main
| `-- java
| `-- com
| `-- mycompany
| `-- a | `-- A .java
`-- test
`-- java
`-- com
`-- mycompany
`-- a `-- A Test.java
四、生成ecli e工程文件
我采用的开发工具是ecli e,所以用maven的ecli e参数生成ecli e工程文件。输入如下
1、 采用dos的cd命令进入study目录
2、 输入指令：mvn ecli e:ecli e 如下所示：
D:\ecli e\work ace\studymvn ecli e:ecli e
指令执行完毕后，发现多了两个文件：.cla ath和.project
五、下载maven的ecli e插件
1、打开ecli e
2、打开菜单 help -Software updates-Find and I tall
3、选择第二项，进入下一步
4、点击按钮“New Remote Site…”
5、在Name中输入：Maven2，在URL中输入http://m2ecli e.codehaus.org/
Ok,现在一切都是自动化的，你所需要做的就是等待并按提示按按钮。
六、导入工程
刚 才已经生成了ecli e的工程文件，现在导入之。菜单File-imp
ort ，按“下一步”，选择工程文件导入完毕后，工程管理透视图就会出现study节点了，在工程节点上，按鼠标右键，打开弹出菜单，选择maven2菜单项， 弹出子菜单-Enable，点击之打开，在Group Id中输入：study即可。
打开study的pom.xml文件，会有如下类似内容：
xml 代码
< roject xml ="http://maven.apache.org/POM/4.0.0" xml :xsi=http://www.w3.org/2001/XMLSchema-i tance xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd"
modelVersio gt;4.0.0/modelVersio gt;
groupIdcom.ef lt;/groupId
artifactId> tudy/artifactId
< ackagingjar/packaging
versio gt;1.0-SNAPSHOT/versio gt;
< ameMaven Quick Start Archetype/name
urlhttp://maven.apache.org/url
/project
注意：有关这个文件的作用和各节点的作用不是本文的描述重点，可以到maven的官方网站查阅http://maven.apache.org/目前为止，所有的准备工作都已经就绪，现在我们就以一个主main函数访问数据库为例介绍在实际开发中的使用。
七、搭建架包
每 一个java工程都不免使用第三方的架包，Maven的好处就是可以统一管理这些架包，并使多个java工程共享这些架包。我们所需要做的就是按规则编辑 pom.xml文件。Maven已经非常智能，使用maven的ecli e插件的向导，只要输入参数就可以将配置文件生成出来。我们的例子是用 jdbc方式访问oracle的数据库。所以需要jdbc和oracle的架包的支持。下面我们就来搭建这两个架包到study工程里来。
有两种方式可以采用：
1、自动向导
第 一种是采用向导方式并让向导直接去maven的服务器上下载你需要的架包，这种方式存在一定的风险，一来可能maven的服务器上并没有你需要的东东，二 来每次智能的maven总是去寻找那并不存在的东东。抛出一大堆红字提示不说，达不到预期目标才是让人郁闷。不过为了保证文档的完整性，还是给出操作步 骤。以junit为例（这个东东倒是没有问题，呵呵）当工程的maven被Enable后，弹出菜单的maven2子菜，选择子菜单的“Add Dependency”菜单项，在Query中输入“junit”，向导会自动列出相关列表供选择。选择你最需要的架包，按“OK” 按钮。
如果你的本地仓库已经存在该架包，则向导只在pom.xml加入依赖项信息，pom.xml文件的内容如下
xml 代码
< roject xml ="http://maven.apache.org/POM/4.0.0" xml :xsi="http://www.w3.org/2001/XMLSchema-i tance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven."apache.org/maven-v4_0_0.xsd
modelVersio gt;4.0.0/modelVersio gt;
groupIdcom.ef lt;/groupId
artifactId> tudy/artifactId
< ackagingjar/packaging
versio gt;1.0-SNAPSHOT/versio gt;
< ameMaven Quick Start Archetype/name
urlhttp://maven.apache.org/url
dependencie gt;
dependency
groupIdjunit/groupId
artifactIdjunit/artifactId
versio gt;3.8.1/versio gt;
/dependency
/dependencie gt;
/project
如果本地仓库没有，则向导会去maven的服务器下载架包，并在控制台输出下载日志如下：
06-8-4 上午09时21分07秒: Local repository folder "" does not exist
06-8-4 上午09时21分11秒: Reading /study/pom.xml
06-8-4 上午09时21分11秒: Local repository folder "" does not exist
06-8-4 上午09时21分18秒: Reading /study/pom.xml
06-8-4 上午09时21分18秒: Local repository folder "" does not exist
06-8-4 上午09时21分19秒: Reading /study/pom.xml
06-8-4 上午09时21分19秒: Local repository folder "" does not exist
06-8-4 上午09时36分33秒: Local repository folder "" does not exist
06-8-4 上午09时37分11秒: Reading / study /pom.xml
06-8-4 上午09时37分11秒: Local repository folder "" does not exist
06-8-4 上午09时37分15秒: Local repository folder "" does not exist
06-8-4 上午09时40分07秒: Local repository folder "" does not exist
06-8-4 上午09时40分08秒: Reading / study /pom.xml
06-8-4 上午09时40分08秒: Local repository folder "" does not exist
06-8-4 上午09时46分24秒: Reading / study /pom.xml
06-8-4 上午09时46分24秒: Local repository folder "" does not exist
06-8-4 上午09时46分28秒: Local repository folder "" does not exist
06-8-4 上午09时46分40秒: Local repository folder "" does not exist
06-8-4 上午09时46分47秒: Local repository folder "" does not exist
06-8-4 上午09时46分47秒: Reading / study /pom.xml
06-8-4 上午09时46分47秒: Local repository folder "" does not exist
06-8-4 上午09 时46 分49 秒: Downloading [central] - http://repo1.maven.org/maven2/junit/junit/3.8.1/junit-3.8.1.pom
06-8-4 上午09 时46 分49 秒: Downloaded [central] - http://repo1.maven.org/maven2/junit/junit/3.8.1/junit-3.8.1.pom
06-8-4 上午09 时46 分51 秒: Downloading [central] - http://repo1.maven.org/maven2/junit/junit/3.8.1/junit-3.8.1.jar
06-8-4 上午09时47分00秒: Downloaded [central] - http://repo1.maven.org/maven2/junit/junit/3.8.1/junit-3.8.1.jar
----------------------------------------------------------------
补充修正：如果出现错误提示同时你手头也有架包的话可以采用maven的指令进行本地化***。比如我在***hibernate的架包时告诉我jta无法下载。要求本地化***，给出的提示如下：
1) javax.tra action:jta:jar:1.0.1B
Try downloading the file manually from:http://java.sun.com/products/jta.Then, i tall it using the command:
mvn i tall:i tall-file -DgroupId=javax.tra action -DartifactId=jta \ -Dversion=1.0.1B -Dpackaging=jar -Dfile=/path/to/filePath to dependency:
1) com.efn:myweba :war:1.0-SNAPSHOT
2) org.hibernate:hibernate:jar:3.1rc2
3) javax.tra action:jta:jar:1.0.1B
----------
1 required artifact is mi ing.for artifact: com.efn:myweba -1.0-SNAPSHOT.war这个提示是说可以先到sun的网站下载jta架包，然后采用命令行的方式按要求安 装，因为我本来就有此架包，于是拷到一个方便的位置，比如c:\,然后在命令行下输入：
mvn i tall:i tall-file -DgroupId=javax.tra action -DartifactId=jta -Dversion=1.0.1B -Dpackaging=jar -Dfile=C:/jta.jar
执行完毕后，一切OK!
--------------------------------------------------------------
2、手工配置
手 工配置比起自动化来说是麻烦了些，不过任何东东掌握在自己手里总归是吃饱喝足谁也不服了不是J。而且配置一次就可以受益终身。更重要的是能解决自动化完成 不了的任务。比如我现在要配置oracle的jdbc驱动，采用自动化就提示我下载不了让我改变下载地址等等，真累。
算了还是自己来吧。
手 工配置前还是先介绍一下相关背景知识。首先了解一下jar仓库的概念，maven采用集中化的方式管理架包，凡用maven构建的java工程都可以重用 统一管理下的架包，所以必须有一个统一存放jar文件的地方，这就是jar仓库，不论是开发还是部署都会建立一个本地仓库。这个仓库的位置默认是 X:\Documents and Settings\Administrator.LIPENG\.m2\repository（X是你操作系统所在盘符）下，你可以修改配置文件改变默认 的输出位置。该配置文件在maven目录下的conf子目录下。文件名叫settings.xml。在配置文件中加入如下节点信息即可 D:/Repository。不过不建议改变，好像ecli e的maven插件只认默认的输出位置。我就是在这方面出了问题搞了半天才发现是输出路径 的问题，也许是我还
没有玩转插件。谁要是解决此问题别忘了跟大家共享。
现在我们分析一下配置文件pom.xml的结构，以junit为例，格式如下：
xml 代码
dependencie gt;
dependency
groupIdjunit/groupId
artifactIdjunit/artifactId
versio gt;3.8.1/versio gt;
/dependency
/dependencie gt;
在来看看本地仓库目录结构
Repository
`-- junit
|-- junit
| `-- 3.8.1
| `-- junit-3.8.1.jar
现在大家应该明白了吧，多余的话不说啦。照葫芦画瓢就是。不过注意先建目录后写配置文件，否则一旦保存，智能的插件就马上开始下载了…
现在开始手动建立oracle的jdbc目录并配置文件,首先建立目录结构如下：
Repository
`-- ojdbc
|-- ojdbc
| `-- 14
| `-- ojdbc-14.jar
如果你手头的jar文件名叫ojdbc14.jar，则改为ojdbc-14.jar,写配置文件:
xml 代码
dependency
groupIdojdbc/groupId
artifactIdojdbc/artifactId
versio gt;14/versio gt;
/dependency
那么现在一个完整的pom.xml文件如下：
xml 代码
?xml version="1.0"?
< roject
modelVersio gt;4.0.0/modelVersio gt;
groupIdcom.mycompany.a lt;/groupId
artifactIdmya lt;/artifactId
< ameMaven Quick Start Archetype/name
versio gt;1.0-SNAPSHOT/versio gt;
urlhttp://maven.apache.org/url
dependencie gt;
dependency
groupIdojdbc/groupId
artifactIdojdbc/artifactId
versio gt;14/versio gt;
/dependency
dependency
groupIdjunit/groupId
artifactIdjunit/artifactId
versio gt;3.8.1/versio gt;
/dependency
/dependencie gt;
/project
保存之，则发现工程管理透视图发生了一点变化,依此方法再加上jdbc的架包，现在可以开始写程序了，建一个类并添加main函数，编写程序如下：
java 代码
public static void main( String[] args )
Co ection co = null;
PreparedStatement = null;
ResultSet rs = null;
Cla .forName("oracle.jdbc.driver.OracleDriver");
co = DriverManager.getCo ection("jdbc:oracle:thin:@(description=(addre _list=(addre =(protocol=TCP)(port=1521)(host=192.168.0.240)))(co ect_da
ta=(SERVER = DEDICATED)(SERVICE_NAME = db.efriendnet.com)))", "efnx", "efnx"); = co .prepareStatement("select * From tb_partyinfo");
rs = .executeQuery();
while(rs.next())
System.out.println(rs.getString("topic"));
} catch (Exception e) {
System.out.print(e.getMe age());
finally
if (rs != null) {try {rs.close();} catch (SQLException e) {}}
if ( != null) {try { .close();} catch (SQLException e) {}}
if (co != null) {try {co .close();} catch (SQLException e) {}}
别忘了imp
ort相应的包
八、编译程序
采 用maven构建系统，则编译过程就独立了出来。这时你再用ecli e自带的编译工具就不起作用了。所以要想编译、调试、运行还要做一些工作。以前是 在dos命令行方式下进行编译，现在的插件很好用，在ecli e配置一下就可以编译了。很方便。现在就做一个介绍。
Ecli e有一个扩展工具就是用来集成其他构建工具的在工程的节点上点击鼠标右键，选择属性，在“编译”的右边窗口选择”新建”按钮，在对话框的“name”中输入：study,点击“Browse Work ace…”列出工程列表供选择。
选择完毕后，在goals中输入package。别忘了a ly.好了，让我们Run吧。如果一切正常，
控制台会打出maven的编译信息如下：
[INFO] ---------------------------------------------------------------------
[INFO] Building Maven Quick Start Archetype
[INFO] task-segment: [package]
[INFO] ---------------------------------------------------------------------
[INFO] resources:resources
[INFO] Using default encoding to copy filtered resources.
[INFO] compiler:compile
[INFO] Nothing to compile - all cla es are up to date
[INFO] resources:testResources
[INFO] Using default encoding to copy filtered resources.
[INFO] compiler:testCompile
[INFO] Nothing to compile - all cla es are up to date
[INFO] surefire:test
[INFO] Surefire report directory: D:\ecli e\work ace\study\target\s
urefire-reports
-------------------------------------------------------
T E S T S
-------------------------------------------------------
Ru ing com.efn.A Test
Tests run: 1, Failures: 0, Errors: 0, Ski ed: 0, Time ela ed: 0.157 sec
Results :
Tests run: 1, Failures: 0, Errors: 0, Ski ed: 0
[INFO] jar:jar
[INFO] Building jar: D:\ecli e\work ace\study\target\study-1.0-SNAPSHOT.jar
[INFO] ----------------------------------------------------------------------------
[INFO] BUILD SUCCESSFUL
[INFO] ---------------------------------------------------------------------
[INFO] Total time: 4 second
[INFO] Finished at: Fri Aug 04 10:55:42 CST 2006
[INFO] Memory 2M/7M
[INFO] --------------------------------------------------------------------
注意，别忘了每一次程序改动完毕后都要经过这一步编译。因为这是maven的编译器！
九、调试程序
经过以上步骤我们已经完成了mave管理下的软件生命周期，但是作为一个程序开发人员我们还要进行调试。这里的调试设置和普通的java程序的调试是一样的。
首先，打开debug对话框：
因为是一个一般的java应用程序，所以我们选择 Java A lication,点击“New”按钮，输入一些相应的参数，a ly-Debug
Ok,一切正常！希望你也顺利！
十、结束语
本文只是简单的对maven的操作步骤做一个指南性的说明，实际应用还有很多东西需要实践。如果发现哪里有错误和纰漏也欢迎批评指正！
( Mon, 15 Mar 2010 17:51:19 +0800 )
Description:
我们要做到不但会写SQL,还要做到写出性能优良的SQL,以下为笔者学习、摘录、并汇总部分资料与大家分享！
（1） 选择最有效率的表名顺序(只在基于规则的优化器中有效)：
ORACLE 的解析器按照从右到左的顺序处理FROM子句中的表名，FROM子句中写在最后的表(基础表 driving table)将被最先处理，在FROM子句中包含多个表的情况下,你必须选择记录条数最少的表作为基础表。如果有3个以上的表连接查询, 那就需要选择交叉表(intersection table)作为基础表, 交叉表是指那个被其他表所引用的表.
（2） WHERE子句中的连接顺序．：
ORACLE采用自下而上的顺序解析WHERE子句,根据这个原理,表之间的连接必须写在其他WHERE条件之前, 那些可以过滤掉最大数量记录的条件必须写在WHERE子句的末尾.
（3） SELECT子句中避免使用 ‘ * ‘：
ORACLE在解析的过程中, 会将'*' 依次转换成所有的列名, 这个工作是通过查询数据字典完成的, 这意味着将耗费更多的时间
（4） 减少访问数据库的次数：
ORACLE在内部执行了许多工作: 解析SQL语句, 估算索引的利用率, 绑定变量 , 读数据块等；
（5） 在SQL*Plus , SQL*Forms和Pro*C中重新设置ARRAYSIZE参数, 可以增加每次数据库访问的检索数据量 ,建议值为200
（6） 使用DECODE函数来减少处理时间：
使用DECODE函数可以避免重复扫描相同记录或重复连接相同的表.
（7） 整合简单,无关联的数据库访问：
如果你有几个简单的数据库查询语句,你可以把它们整合到一个查询中(即使它们之间没有关系)
（8） 删除重复记录：
最高效的删除重复记录方法 ( 因为使用了ROWID)例子：
DELETE FROM EMP E WHERE E.ROWID (SELECT MIN(X.ROWID)
FROM EMP X WHERE X.EMP_NO = E.EMP_NO);
（9） 用TRUNCATE替代DELETE：
当删除表中的记录时,在通常情况下, 回滚段(rollback segments ) 用来存放可以被恢复的信息. 如果你没有COMMIT事务,ORACLE会将数据恢复到删除之前的状态(准确地说是恢复到执行删除命令之前的状况) 而当运用TRUNCATE时, 回滚段不再存放任何可被恢复的信息.当命令运行后,数据不能被恢复.因此很少的资源被调用,执行时间也会很短. (译者按: TRUNCATE只在删除全表适用,TRUNCATE是DDL不是DML)
（10） 尽量多使用COMMIT：
只要有可能,在程序中尽量多使用COMMIT, 这样程序的性能得到提高,需求也会因为COMMIT所释放的资源而减少:
COMMIT所释放的资源:
a. 回滚段上用于恢复数据的信息.
b. 被程序语句获得的锁
c. redo log buffer 中的空间
d. ORACLE为管理上述3种资源中的内部花费
（11） 用Where子句替换H***ING子句：
避免使用H***ING子句, H***ING 只会在检索出所有记录之后才对结果集进行过滤. 这个处理需要排序,总计等操作. 如果能通过WHERE子句限制记录的数目,那就能减少这方面的开销. (非oracle中)on、where、having这三个都可以加条件的子句中，on是最先执行，where次之，having最后，因为on是先把不符合条件的记录过滤后才进行统计，它就可以减少中间运算要处理的数据，按理说应该速度是最快的，where也应该比having快点的，因为它过滤数据后才进行sum，在两个表联接时才用on的，所以在一个表的时候，就剩下where跟having比较了。在这单表查询统计的情况下，如果要过滤的条件没有涉及到要计算字段，那它们的结果是一样的，只是where可以使用rushmore技术，而having就不能，在速度上后者要慢如果要涉及到计算的字段，就表示在没计算之前，这个字段的值是不确定的，根据上篇写的工作流程，where的作用时间是在计算之前就完成的，而having就是在计算后才起作用的，所以在这种情况下，两者的结果会不同。在多表联接查询时，on比where更早起作用。系统首先根据各个表之间的联接条件，把多个表合成一个临时表后，再由where进行过滤，然后再计算，计算完后再由having进行过滤。由此可见，要想过滤条件起到正确的作用，首先要明白这个条件应该在什么时候起作用，然后再决定放在那里
（12） 减少对表的查询：
在含有子查询的SQL语句中,要特别注意减少对表的查询.例子： SELECT TAB_NAME FROM TABLES WHERE (TAB_NAME,DB_VER) = ( SELECT
TAB_NAME,DB_VER FROM TAB_COLUMNS WHERE VERSION = 604)
（13） 通过内部函数提高SQL效率.：
复杂的SQL往往牺牲了执行效率. 能够掌握上面的运用函数解决问题的方法在实际工作中是非常有意义的
（14） 使用表的别名(Alias)：
当在SQL语句中连接多个表时, 请使用表的别名并把别名前缀于每个Column上.这样一来,就可以减少解析的时间并减少那些由Column歧义引起的语法错误.
（15） 用EXISTS替代IN、用NOT EXISTS替代NOT IN：
在许多基于基础表的查询中,为了满足一个条件,往往需要对另一个表进行联接.在这种情况下, 使用EXISTS(或NOT EXISTS)通常将提高查询的效率. 在子查询中,NOT IN子句将执行一个内部的排序和合并. 无论在哪种情况下,NOT IN都是最低效的 (因为它对子查询中的表执行了一个全表遍历). 为了避免使用NOT IN ,我们可以把它改写成外连接(Outer Joi )或NOT EXISTS.
例子：
（高效）SELECT * FROM EMP (基础表) WHERE EMPNO 0 AND EXISTS (SELECT ‘X' FROM DEPT WHERE DEPT.DEPTNO = EMP.DEPTNO AND LOC = ‘MELB')
(低效)SELECT * FROM EMP (基础表) WHERE EMPNO 0 AND DEPTNO IN(SELECT DEPTNO FROM DEPT WHERE LOC = ‘MELB')
（16） 识别'低效执行'的SQL语句：
虽然目前各种关于SQL优化的图形化工具层出不穷,但是写出自己的SQL工具来解决问题始终是一个最好的方法：
SELECT EXECUTIONS , DISK_READS, BUFFER_GETS,
ROUND((BUFFER_GETS-DISK_READS)/BUFFER_GETS,2) Hit_radio,
ROUND(DISK_READS/EXECUTIONS,2) Reads_per_run,
SQL_TEXT
FROM V$SQLAREA
WHERE EXECUTIONS0
AND BUFFER_GETS 0
AND (BUFFER_GETS-DISK_READS)/BUFFER_GETS 0.8
ORDER BY 4 DESC;
（17） 用索引提高效率：
索引是表的一个概念部分,用来提高检索数据的效率，ORACLE使用了一个复杂的自平衡B-tree结构. 通常,通过索引查询数据比全表扫描要快. 当ORACLE找出执行查询和Update语句的最佳路径时, ORACLE优化器将使用索引. 同样在联结多个表时使用索引也可以提高效率. 另一个使用索引的好处是,它提供了主键(primary key)的唯一性验证.。那些LONG或LONG RAW数据类型, 你可以索引几乎所有的列. 通常, 在大型表中使用索引特别有效. 当然,你也会发现, 在扫描小表时,使用索引同样能提高效率. 虽然使用索引能得到查询效率的提高,但是我们也必须注意到它的代价. 索引需要空间来存储,也需要定期维护, 每当有记录在表中增减或索引列被修改时, 索引本身也会被修改. 这意味着每条记录的INSERT , DELETE , UPDATE将为此多付出4 , 5 次的磁盘I/O . 因为索引需要额外的存储空间和处理,那些不必要的索引反而会使查询反应时间变慢.。定期的重构索引是有必要的.：
ALTER INDEX INDEXNAME REBUILD TABLESPACENAME
18） 用EXISTS替换DISTINCT：
当提交一个包含一对多表信息(比如部门表和雇员表)的查询时,避免在SELECT子句中使用DISTINCT. 一般可以考虑用EXIST替换, EXISTS 使查询更为迅速,因为RDBMS核心模块将在子查询的条件一旦满足后,立刻返回结果. 例子： (低效):
SELECT DISTINCT DEPT_NO,DEPT_NAME FROM DEPT D , EMP E
WHERE D.DEPT_NO = E.DEPT_NO
(高效):
SELECT DEPT_NO,DEPT_NAME FROM DEPT D WHERE EXISTS ( SELECT ‘X'
FROM EMP E WHERE E.DEPT_NO = D.DEPT_NO);
（19） sql语句用大写的；因为oracle总是先解析sql语句，把小写的字母转换成大写的再执行
（20） 在java代码中尽量少用连接符“＋”连接字符串！
（21） 避免在索引列上使用NOT 通常，　
我们要避免在索引列上使用NOT, NOT会产生在和在索引列上使用函数相同的影响. 当ORACLE”遇到”NOT,他就会停止使用索引转而执行全表扫描.
（22） 避免在索引列上使用计算．
WHERE子句中，如果索引列是函数的一部分．优化器将不使用索引而使用全表扫描．
举例:
低效：
SELECT … FROM DEPT WHERE SAL * 12 25000;
高效:
SELECT … FROM DEPT WHERE SAL 25000/12;
（23） 用=替代
高效:
SELECT * FROM EMP WHERE DEPTNO =4
低效:
SELECT * FROM EMP WHERE DEPTNO 3
两者的区别在于, 前者DBMS将直接跳到第一个DEPT等于4的记录而后者将首先定位到DEPTNO=3的记录并且向前扫描到第一个DEPT大于3的记录.
（24） 用UNION替换OR (适用于索引列)
通常情况下, 用UNION替换WHERE子句中的OR将会起到较好的效果. 对索引列使用OR将造成全表扫描. 注意, 以上规则只针对多个索引列有效. 如果有column没有被索引, 查询效率可能会因为你没有选择OR而降低. 在下面的例子中, LOC_ID 和REGION上都建有索引.
高效:
SELECT LOC_ID , LOC_DESC , REGION
FROM LOCATION
WHERE LOC_ID = 10
SELECT LOC_ID , LOC_DESC , REGION
FROM LOCATION
WHERE REGION = “MELBOURNE”
低效:
SELECT LOC_ID , LOC_DESC , REGION
FROM LOCATION
WHERE LOC_ID = 10 OR REGION = “MELBOURNE”
如果你坚持要用OR, 那就需要返回记录最少的索引列写在最前面.
（25） 用IN来替换OR 这是一条简单易记的规则，但是实际的执行效果还须检验，在ORACLE8i下，两者的执行路径似乎是相同的．　
低效:
SELECT…. FROM LOCATION WHERE LOC_ID = 10 OR LOC_ID = 20 OR LOC_ID = 30
SELECT… FROM LOCATION WHERE LOC_IN IN (10,20,30);
（26） 避免在索引列上使用IS NULL和IS NOT NULL
避免在索引中使用任何可以为空的列，ORACLE将无法使用该索引．对于单列索引，如果列包含空值，索引中将不存在此记录. 对于复合索引，如果每个列都为空，索引中同样不存在此记录.　如果至少有一个列不为空，则记录存在于索引中．举例: 如果唯一性索引建立在表的A列和B列上, 并且表中存在一条记录的A,B值为(123,null) , ORACLE将不接受下一条具有相同A,B值（123,null）的记录(插入). 然而如果所有的索引列都为空，ORACLE将认为整个键值为空而空不等于空. 因此你可以插入1000 条具有相同键值的记录,当然它们都是空! 因为空值不存在于索引列中,所以WHERE子句中对索引列进行空值比较将使ORACLE停用该索引.
低效: (索引失效)
SELECT … FROM DEPARTMENT WHERE DEPT_CO
DE IS NOT NULL;
高效: (索引有效)
SELECT … FROM DEPARTMENT WHERE DEPT_CO
（27） 总是使用索引的第一个列：
如果索引是建立在多个列上, 只有在它的第一个列(leading column)被where子句引用时,优化器才会选择使用该索引. 这也是一条简单而重要的规则，当仅引用索引的第二个列时,优化器使用了全表扫描而忽略了索引
28） 用UNION-ALL 替换UNION ( 如果有可能的话)：
当SQL 语句需要UNION两个查询结果集合时,这两个结果集合会以UNION-ALL的方式被合并, 然后在输出最终结果前进行排序. 如果用UNION ALL替代UNION, 这样排序就不是必要了. 效率就会因此得到提高. 需要注意的是，UNION ALL 将重复输出两个结果集合中相同记录. 因此各位还是要从业务需求分析使用UNION ALL的可行性. UNION 将对结果集合排序,这个操作会使用到SORT_AREA_SIZE这块内存. 对于这块内存的优化也是相当重要的. 下面的SQL可以用来查询排序的消耗量
低效：
SELECT ACCT_NUM, BALANCE_AMT
FROM DEBIT_TRANSACTIONS
WHERE TRAN_DATE = '31-DEC-95'
SELECT ACCT_NUM, BALANCE_AMT
FROM DEBIT_TRANSACTIONS
WHERE TRAN_DATE = '31-DEC-95'
高效:
SELECT ACCT_NUM, BALANCE_AMT
FROM DEBIT_TRANSACTIONS
WHERE TRAN_DATE = '31-DEC-95'
UNION ALL
SELECT ACCT_NUM, BALANCE_AMT
FROM DEBIT_TRANSACTIONS
WHERE TRAN_DATE = '31-DEC-95'
（29） 用WHERE替代ORDER BY：
ORDER BY 子句只在两种严格的条件下使用索引.
ORDER BY中所有的列必须包含在相同的索引中并保持在索引中的排列顺序.
ORDER BY中所有的列必须定义为非空.
WHERE子句使用的索引和ORDER BY子句中所使用的索引不能并列.
例如:
表DEPT包含以下列:
DEPT_CO
DE PK NOT NULL
DEPT_DESC NOT NULL
DEPT_TYPE NULL
低效: (索引不被使用)
SELECT DEPT_CO
DE FROM DEPT ORDER BY DEPT_TYPE
高效: (使用索引)
SELECT DEPT_CO
DE FROM DEPT WHERE DEPT_TYPE 0
（30） 避免改变索引列的类型.:
当比较不同数据类型的数据时, ORACLE自动对列进行简单的类型转换.
假设 EMPNO是一个数值类型的索引列.
SELECT … FROM EMP WHERE EMPNO = ‘123'
实际上,经过ORACLE类型转换, 语句转化为:
SELECT … FROM EMP WHERE EMPNO = TO_NUMBER(‘123')
幸运的是,类型转换没有发生在索引列上,索引的用途没有被改变.
现在,假设EMP_TYPE是一个字符类型的索引列.
SELECT … FROM EMP WHERE EMP_TYPE = 123
这个语句被ORACLE转换为:
SELECT … FROM EMP WHERETO_NUMBER(EMP_TYPE)=123
因为内部发生的类型转换, 这个索引将不会被用到! 为了避免ORACLE对你的SQL进行隐式的类型转换, 最好把类型转换用显式表现出来. 注意当字符和数值比较时, ORACLE会优先转换数值类型到字符类型
（31） 需要当心的WHERE子句:
某些SELECT 语句中的WHERE子句不使用索引. 这里有一些例子.
在下面的例子里, (1)‘!=' 将不使用索引. 记住, 索引只能告诉你什么存在于表中, 而不能告诉你什么不存在于表中. (2) ‘||'是字符连接函数. 就象其他函数那样, 停用了索引. (3) ‘+'是数学函数. 就象其他数学函数那样, 停用了索引. (4)相同的索引列不能互相比较,这将会启用全表扫描.
（32） a. 如果检索数据量超过30%的表中记录数.使用索引将没有显著的效率提高.
b. 在特定情况下, 使用索引也许会比全表扫描慢, 但这是同一个数量级上的区别. 而通常情况下,使用索引比全表扫描要块几倍乃至几千倍!
（33） 避免使用耗费资源的操作:
带有DISTINCT,UNION,MINUS,INTERSECT,ORDER BY的SQL语句会启动SQL引擎
执行耗费资源的排序(SORT)功能. DISTINCT需要一次排序操作, 而其他的至少需要执行两次排序. 通常, 带有UNION, MINUS , INTERSECT的SQL语句都可以用其他方式重写. 如果你的数据库的SORT_AREA_SIZE调配得好, 使用UNION , MINUS, INTERSECT也是可以考虑的, 毕竟它们的可读性很强
（34） 优化GROUP BY:
提高GROUP BY 语句的效率, 可以通过将不需要的记录在GROUP BY 之前过滤掉.下面两个查询返回相同结果但第二个明显就快了许多.
低效:
SELECT JOB , ***G(SAL)
FROM EMP
GROUP by JOB
H***ING JOB = ‘PRESIDENT'
OR JOB = ‘MANAGER'
高效:
SELECT JOB , ***G(SAL)
FROM EMP
WHERE JOB = ‘PRESIDENT'
OR JOB = ‘MANAGER'
GROUP by JOB
( Mon, 15 Mar 2010 16:43:20 +0800 )
Description:
关键字: java oo 模型
用途及用法 网络请求通常有两种形式：第一种，请求不是很频繁，而且每次连接后会保持相当一段时间来读数据或者写数据，最后断开，如文件下载，网络流媒体等。另一种形式是请求频繁，但是连接上以后读/写很少量的数据就断开连接。考虑到服务的并发问题，如果每个请求来到以后服务都为它启动一个线程，那么这对服务的资源可能会造成很大的浪费，特别是第二种情况。因为通常情况下，创建线程是需要一定的耗时的，设这个时间为T1，而连接后读/写服务的时间为T2，当T1T2时，我们就应当考虑一种策略或者机制来控制，使得服务对于第二种请求方式也能在较低的功耗下完成。
通常，我们可以用线程池来解决这个问题，首先，在服务启动的时候，我们可以启动好几个线程，并用一个容器(如线程池)来管理这些线程。当请求到来时，可以从池中去一个线程出来，执行任务(通常是对请求的响应)，当任务结束后，再将这个线程放入池中备用；如果请求到来而池中没有空闲的线程，该请求需要排队等候。最后，当服务关闭时销毁该池即可。
线程池中通常由这样几个概念(接口)组成：
线程池(Thread pool )，池是一个容器，容器中有很多个执行器，每一个执行器是一个线程。当然，这个容器的实现，可以是链表，可以是数组等等，不需要关心，需要关心的是，池必须提供一个可以从中取出执行器 的方法，可能还需要一个池中现有活动线程数方法，销毁池的方法等。
执行器(Executor )，每个执行器是一个线程，每个执行器可以执行一个任务 ，任务是做什么，此时还不很明确，它需要提供任务的setter/getter方法，并且作为一个线程，他可以独立运行，执行器执行完自身后，需要将自身放入池中。
任务(Task )，任务是每个线程具体要做的事，如资源下载，播放flash片段，打印一段文字到控制台等等，它本身不能执行，而需要将自身交给执行器。
整个池的机制和结构就是这样，当然，需要一个调度者(scheduler)来协调主线程和池的关系。结构，或者接口的目的是为了让我们从细节中解脱出来，从一个比较抽象的层次来描述系统，这样的好处是简单，而且设计出来的框架比较通用，可以适应很多相近相似的情况。由于Task具体干什么我们不知道，所以它几乎可以干任何适应于上边总结的网络连接的第二种情况(T1T2)。
类的结构图
虽然为一个简单的实现设计一个标准的UML视图是不太现实的，但是这是一种受鼓励的做法，至少应该用铅笔在草纸上画出相关的视图，这样可以帮助以后的维护和更高级的扩展。
线程池的简单实现
实现可以是通过多种语言的，我们在此选择面向对象的J***A，而如果你使用C的话，也没有问题，问题在上一小节已经描述清楚，语言是不重要的。
池是一个容器，我们考虑使用java.util.LinkedList类(可能由于它的长度是可变的，而且不需要我们使用者来考虑)，也就是说，池需要维护一个链表。 Java代码
public interface Pool {//池接口 Executor getExecutor(); void destroy(); } public interface Pool {//池接口 Executor getExecutor(); void destroy();} Java代码
public interface Executor {//执行器接口 void etTask(Task task); Task getTask(); void tartTask(); } public interface Executor {//执行器接口 void setTask(Task task); Task getTask(); void startTask();} 鉴于执行器是池中的对象，而且外部没有必要知道其细节，我们考虑将Executor接口的实现做为Pool接口的实现的内部类。这样做的另一个好处是，更便于池的管理。 Java代码
ort java.util.LinkedList; imp
ort java.util.Propertie imp
ort redesigned.utils.PropReader; public cla ThreadPool implement Pool{ rivate oolea isShut; rivate LinkedList ool; rivate tatic Propertie ro = PropReader.getProperties("webconfig.properties"); rivate int ize = Integer.parseInt(prop.getProperty("thread erpage", "3")); ublic ThreadPool(){ // read configuratio and et the // content of ool y object of Executor isShut = false;//set the tatu of ool to active ool = ew LinkedList(); for(int i = 0 i lt ize i++){ Executor executor = ew ExecutorImpl();//new a executor thread ool.add(executor);//add it to ool ((ExecutorImpl)executor).start();//start it } } ublic void destroy() {//Destroy ynchronized(pool){ isShut = true;//set the tatu of ool to inactive ool.notifyAll();//notify all listener. ool.clear();//clear the list of threads } } ublic Executor getExecutor(){ Executor ret = ull; ynchronized(pool){//retur if any. if(pool.size() gt 0){ ret = (Executor)pool.removeFirst(); }else{ try { ool.wait(); } catch (InterruptedExceptio e) { e.printStackTrace(); } ret = (Executor)pool.removeFirst(); } } retur ret; } Executor接口的实现作为ThreadPool的内部类 rivate cla ExecutorImpl extend Thread implement Executor{ rivate Task task; rivate Object lock = ew Object(); //private oolea loo = true; ublic ExecutorImpl(){} ublic Task getTask() { retur this.task; } ublic void etTask(Task task) { this.task = task; } ublic void tartTask(){ //System.out.println("start here"); ynchronized(lock){ lock.notify(); } } ublic void run(){ //get a task if any //the ru it //the ut elf to ool while(!isShut){ ynchronized(lock){ try { lock.wait();//wait for resource } catch (InterruptedExceptio e) { e.printStackTrace(); } } getTask().execute();//execute the task ynchronized(pool){//put it elf to the ool whe finish the task ool.addFirst(ExecutorImpl.this); ool.notifyAll(); } } } } } imp
ort java.util.LinkedList;
ort java.util.Propertie imp
ort redesigned.utils.PropReader;
public cla ThreadPool implements Pool{ private boolean isShut; private LinkedList pool; private static Properties prop = PropReader.getProperties("webconfig.properties"); private int size = Integer.parseInt(prop.getProperty("thread erpage", "3")); public ThreadPool(){ // read configuration and set the // content of pool by objects of Executor isShut = false;//set the status of pool to active pool = new LinkedList(); for(int i = 0; i size; i++){ Executor executor = new ExecutorImpl();//new a executor thread pool.add(executor);//add it to pool ((ExecutorImpl)executor).start();//start it } } public void destroy() {//Destroy synchronized(pool){ isShut = true;//set the status of pool to inactive pool.notifyAll();//notify all listener. pool.clear();//clear the list of threads } } public Executor getExecutor(){ Executor ret = null; synchronized(pool){//return if any. if(pool.size() 0){ ret = (Executor)pool.removeFirst(); }else{ try { pool.wait(); } catch (InterruptedException e) { e.printStackTrace(); } ret = (Executor)pool.removeFirst(); } } return ret; }
Executor接口的实现作为ThreadPool的内部类 private cla ExecutorImpl extends Thread implements Executor{ private Task task; private Object lock = new Object(); //private boolean loop = true; public ExecutorImpl(){} public Task getTask() { return this.task; } public void setTask(Task task) { this.task = task; } public void startTask(){ //System.out.println("start here"); synchronized(lock){ lock.notify(); } } public void run(){ //get a task if any //then run it //then put self to pool while(!isShut){ synchronized(lock){ try { lock.wait();//wait for resource } catch (InterruptedException e) { e.printStackTrace(); } } getTask().execute();//execute the task synchronized(pool){//put it self to the pool when finish the task pool.addFirst(ExecutorImpl.this); pool.notifyAll(); } } } }
} 好了，池设计好了，再来看看任务(Task)的接口和实现
Java代码
public interface Task {//这个接口也比较简单，可以执行，可以取到执行结果 void execute(); yte[] getResult(); } public interface Task {//这个接口也比较简单，可以执行，可以取到执行结果 void execute(); byte[] getResult();} Task的实现可以是多种多样的，下边的例子是一个加载资源的Task.使用方式 Java代码
Pool ool = ew ThreadPool();// ew a ThreadPool //load resource o each age, and tart # of thread. for(int i = 0 i lt resourceList.size();i++){ Executor executor = ool.getExecutor() // get Executor form ool Task resourceLoader = ew ResourceLoader((String)resourceList.get(i)); executor.setTask(resourceLoader) // et the task to executor executor.startTask() // try to tart the executor. } //wait while all task are done, the destroy the ool. pool.destroy() Pool pool = new ThreadPool();// new a ThreadPool
//load resources on each page, and start #s of thread.
for(int i = 0; i resourceList.size();i++){ Executor executor = pool.getExecutor(); // get Executor form pool Task resourceLoader = new ResourceLoader((String)resourceList.get(i)); executor.setTask(resourceLoader); // set the task to executor executor.startTask(); // try to start the executor.
//wait while all task are done, the destroy the pool.
pool.destroy(); 优势，或者适用范围
在并发时，需要被并发的线程不需要知道自己什么时候需要被启动，它子需要考虑这样一种情况：它自己从一个地方取出来一个执行器，然后把任务交给执行器，然后等待执行器结束即可，他关心的是自己所需要干的事，或者自己负责的事。这样，大家都简单，因为只需要做好自己的事情就好了。面向对象的一个秘诀为：永远相信合作者，使用别人的接口而不是自己去实现所有的接口。
这种T1T2的请求方式在网络中固然是常见的，在实际问题中同样是常见的。因此，掌握这种模式可能会对我们以后的程序设计提供方便和好处。
同步问题： 同步在线程的并发中意义非常之大，对临界资源的控制是并发时最关键的地方。如在线程池中，当池中没有空闲的线程时，新来的请求就必须等待，而一旦一个Task运行结束后，一方面将自己放入池中，一方面需要通知等待在pool中的其他线程。每一个执行器线程，一开始启动，则进入等待状态，此时不会消耗CPU资源。而当在外部调用执行器的startTask()方法，即可通知线程从等待状态中醒来，去出Task，执行之，将执行器本身放入池中，然后继续等待。 当然，实现的策略是可以多种多样的，但是问题的本质已经在第二小节结构 很明确的被定义了。 最近开始学习J***A，同时也开始熟悉面向对象的思维方式，这篇日志，一来作为一个备忘，二来可以对可能需要的人提供帮助。以上可以算作是小结。
( Mon, 22 Feb 2010 17:17:20 +0800 )
Description:
Ajax.Request(
method:method,
parameters:para,
postBody:xmlString,
asynchronous:true,
setRequestHeader:Object,
Complete:completeFun,
Error:errorFun
发送异步请求。（此方法是为兼容 prototype.js 而写，调用风格与 prototype 一致,使用Ajax.Request此方法请在页面中加载此js文件）
必选项。数据发送的目标地址。
可选项。数据提交的方式，默认值为get。常用的还有post。
parameters
当 method 为 get 时是可选项，为 post 时是必选项。发送的数据，其形式为： name1=valeu1&am name2=value2&am ame3=value3......
postBody
可选项。客户端发送的 xml 格式字符串。如果启用 postBody，那么 parameters 将被忽略。
asynchronous
可选项。指定请求是否异步，默认为true（异步）。
setRequestHeader
指定请求的头部字串。其值类型为“名称值对”形式的对象，比如：{"If-Modified-Since":"0", "SOAPAction":"http://tempuri.org/SBS_WebService", ... ... }
Complete
可选项。请求成功时执行的回调函数，该函数默认把当前使用 xmlhttp 对象作为第一个参数。
可选项。请求异常时执行的回调函数，该函数默认把当前使用 xmlhttp 对象作为第一个参数。
返回值
当前使用的 xmlhttp 对象。
发送异步请求，并返回 xmlhttp 对象，该对象内置有 abort() 方法，用于提前终止请求。异步请求成功则执行 on
Complete，失败则执行 on
Error 。并返回 xmlhttp 对象。
Ajax.Request 是个接口完整的 Ajax 方法，是 myJSFrame 中所有其他 Ajax 方法的核心方法。
示例一：
< cript type="text/javas
cript" var myAjax = new Ajax.Request( "http://www.ha yshow.org/form.a ", { method:"post", //表单提交方式 parameters:"name=acai&am age=26&am ex=male", //提交的表单数据 setRequestHeader:{"If-Modified-Since":"0"}, //禁止读取缓存数据 on
Complete:function(x){ //提交成功回调 alert(x.re o eText); }, on
Error:function(x){ //提交失败回调 alert(x.statusText); } } );
/script
注：parameters 参数若是不列出，我们在开发中对于Form 表单这样的数据 可以这样处理 arameters:Form.serialize('FormName') FormName 为页面中表单的 ID 示例二：
< cript type="text/javas
cript" var xmlString = "root" +"< eople> lt amecaizhongqi/name> lt exmale/sex/people" +"< eople> lt ameahuang/name> lt exfemale/sex/people" +" /root"; var myAjax = new Ajax.Request( "http://www.ha yshow.org/xmlform.a ", { method:"post", //表单提交方式 postBody:xmlString, //提交的xml setRequestHeader:{"content-Type":"text/xml"}, //指定发送的数据为 xml 文档（非字符串） on
Complete:function(x){ //提交成功回调 alert(x.re o eXML.xml); }, on
Error:function(x){ //提交失败回调 alert(x.statusText); } } );
/script
( Mon, 25 Jan 2010 14:25:15 +0800 )
Description:
算法是在有限步骤内求解某一问题所使用的一组定义明确的规则。通俗点说，就是计算机解题的过程。在这个过程中，无论是形成解题思路还是编写程序，都是在实施某种算法。前者是推理实现的算法，后者是操作实现的算法。
一个算法应该具有以下五个重要的特征：
1.有穷性： 一个算法必须保证执行有限步之后结束；
2.确切性： 算法的每一步骤必须有确切的定义；
3.输入：一个算法有0个或多个输入，以刻画运算对象的初始情况；
4.输出：一个算法有一个或多个输出，以反映对输入数据加工后的结果。没有输出的算法是毫无意义的；
5.可行性： 算法原则上能够精确地运行，而且人们用笔和纸做有限次运算后即可完成。
合并排序（MERGE SORT）是又一类不同的排序方法，合并的含义就是将两个或两个以上的有序数据序列合并成一个新的有序数据序列，因此它又叫归并算法。它的基本思想就是假设数组A有N个元素，那么可以看成数组A是又N个有序的子序列组成，每个子序列的长度为1，然后再两两合并，得到了一个 N/2 个长度为2或1的有序子序列，再两两合并，如此重复，值得得到一个长度为N的有序数据序列为止，这种排序方法称为2—路合并排序。
例如数组A有7个数据，分别是： 49 38 65 97 76 13 27，那么采用归并排序算法的操作过程如图7所示：
初始值 [49] [38] [65] [97] [76] [13] [27]
看成由长度为1的7个子序列组成
第一次合并之后 [38 49] [65 97] [13 76] [27]
看成由长度为1或2的4个子序列组成
第二次合并之后 [38 49 65 97] [13 27 76]
看成由长度为4或3的2个子序列组成
第三次合并之后 [13 27 38 49 65 76 97]
图6 归并排序算法过程图
合并算法的核心操作就是将一维数组中前后相邻的两个两个有序序列合并成一个有序序列。合并算法也可以采用递归算法来实现，形式上较为简单,但实用性很差。
合并算法的合并次数是一个非常重要的量,根据计算当数组中有3到4个元素时,合并次数
是2次,当有5到8个元素时,合并次数是3次,当有9到16个元素时,合并次数是4次，按照这一规律，当有N个子序列时可以推断出合并的次数是
X（2=N,符合次条件的最小那个X）。
冒泡算法描述：
在解释冒泡排序算法之前，先来介绍把10个数（放在数组A中）中最大的那个数放在最后位置上的一种算法。算法描述如下：
（1）从数组A[1]到A[10]，把相临的两个数两两进行比较。即A[1]和A[2]比较，比较完后A[2]再与A[3]比较，……最后是A[9]和A[10]比较。
(2)在每次进行比较的过程中，如果前一个数比后一个数大，则对调两个数，也就是说把较大的数调到后面，较小的调到前面。比如在第一次的比较中，如果A[1]比A[2]大则A[1]和A[2]的值就互换。下图用6个数据来说明以上的算法。
假设6个数据是：A[]=5 7 4 3 8 6
A[1] A[2] A[3] A[4] A[5] A[6]
5 7 4 3 8 6 第一次，A[1]=5和A[2]=7比较，75，不进行对调。
5 7 4 3 8 6 第二次，A[2]=7和A[3]=4比较，47，进行对调，
那么第二次比较完后的数据是5 4 7 3 8 6
5 4 7 3 8 6 第三次，A[3]=7和A[4]=3比较，37，进行对调，
那么第三次比较完后的数据是5 4 3 7 8 6
5 4 3 7 8 6 第四次，A[4]=7和A[5]=8比较，87,不进行对调。
5 4 3 7 8 6 第五次，A[6]=6和A[5]=8比较，68，进行对调，
那么第五次也就是最后一次的结果是
5 4 3 7 6 8
*******************************************************
选择排序算法描述：
在介绍选择排序法之前先介绍一种把最小的数放在第一个位置上的算法，当然也可以用前面所讲的冒泡排序法，现在我们改用一种新的算法：其指导思想是先并不急于调换位置，先从A[1]开始逐个检查，看哪个数最小就记下该数所在的位置P，等一躺扫描完毕，再把A[P]和A[1]对调，这时A[1]到A[10]中最小的数据就换到了最前面的位置。算法的步骤如下：
1）、先假设A[1]中的数最小，记下此时的位置P=1；
2）、依次把A[P]和A[I]（I从2变化到10）进行比较，每次比较时，若A[I]的数比A[P]中的数小，则把I的值赋给P，使P总是指向当前所扫描过的最小数的位置，也就是说A[P]总是等于所有扫描过的数最小的那个数。在依次一一比较后，P就指向10个数中最小的数所在位置，即A[P]就是10个数中最小的那个数；
3）把A[P]和A[1]的数对调，那么最小的数就在A[1]中去了，也就是在最前面了。
如果现在重复此算法，但每重复一次，进行比较的数列范围就向后移动一个位置。即第二遍比较时范围就从第2个数一直到第N个数，在此范围内找最小的数的位置P，然后把A[P]与A[2]对调，这样从第2个数开始到第N个数中最小数就在A[2]中了，第三遍就从第3个数到第N个数中去找最小的数，再把A[P]与A[3]对调……此过程重复N-1次后，就把A数组中N个数按从小到大的顺序排好了。这种排序的方法就是选择排序法
*****************************************************************
插入排序算法描述：
通过学习上述两种方法可以了解排序的基本思想，也可以对任何一个无序数组作出从大到小（降序）或从小到大（升序）的排列。现在假设有一个已经有序的数据序列，要求在这个已经排好的数据序列中插入一个数，但要求插入后此数据序列仍然有序，这个时候就要用到一种新的排序方法——插入排序法,插入排序的基本操作就是将一个数据插入到已经排好序的有序数据中,从而得到一个新的、个数加一的有序数据。
题目：A数组中有N个数据，按从小到大的顺序排列，输入一个数X，把X的值插入到数组A中，使得插入后的A数组仍然按从小到大排列。
那么这个问题的解决算法就是：
1）、通过比较大小找到X应插入的位置，假如应该放在第I个位置；
2）、把从I开始的（包括I）的所有数组元素依次向后移动一个位置，即A[I+1]：=A[I]；
快速排序是对冒泡排序的一种改进。它的基本思想是：通过一躺排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一不部分的所有数据都要小，然后再按次方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
假设要排序的数组是A[1]……A[N]，首先任意选取一个数据（通常选用第一个数据）作为关键数据，然后将所有比它的数都放到它前面，所有比它大的数都放到它后面，这个过程称为一躺快速排序。一躺快速排序的算法是：
1）、设置两个变量I、J，排序开始的时候I：=1，J：=N；
2）以第一个数组元素作为关键数据，赋值给X，即X：=A[1]；
3）、从J开始向前搜索，即由后开始向前搜索（J：=J-1），找到第一个小于X的值，两者交换；
4）、从I开始向后搜索，即由前开始向后搜索（I：=I+1），找到第一个大于X的值，两者交换；
5）、重复第3、4步，直到I=J；
例如：待排序的数组A的值分别是：（初始关键数据X：=49）
A[1] A[2] A[3] A[4] A[5] A[6] A[7]：
49 38 65 97 76 13 27
进行第一次交换后： 27 38 65 97 76 13 49
( 按照算法的第三步从后面开始找
进行第二次交换后： 27 38 49 97 76 13 65
( 按照算法的第四步从前面开始找X的值，6549,两者交换，此时I：=3 )
进行第三次交换后： 27 38 13 97 76 49 65
( 按照算法的第五步将又一次执行算法的第三步从后开始找
进行第四次交换后： 27 38 13 49 76 97 65
( 按照算法的第四步从前面开始找大于X的值，9749,两者交换，此时J：=4 )
此时再执行第三不的时候就发现I=J，从而结束一躺快速排序，那么经过一躺快速排序之后的结果是：27 38 13 49 76 97 65，即所以大于49的数全部在49的后面，所以小于49的数全部在49的前面。
快速排序就是递归调用此过程——在以49为中点分割这个数据序列，分别对前面一部分和后面一部分进行类似的快速排序，从而完成全部数据序列的快速排序，最后把此数据序列变成一个有序的序列，根据这种思想对于上述数组A的快速排序的全过程如图6所示：
初始状态 {49 38 65 97 76 13 27}
进行一次快速排序之后划分为 {27 38 13} 49 {76 97 65}
分别对前后两部分进行快速排序 {13} 27 {38}
结束 结束 {49 65} 76 {97} 49 {65} 结束
*************************************************************************
图6 快速排序全过程
快速排序的算法描述
1）、设有N（假设N=10）个数，存放在S数组中；
2）、在S[1。。N]中任取一个元素作为比较基准，例如取T=S[1]，起目的就是在定出T应在排序结果中的位置K，这个K的位置在：S[1。。K-1]=S[K]=S[K+1..N]，即在S[K]以前的数都小于S[K]，在S[K]以后的数都大于S[K]；
3）、利用分治思想（即大化小的策略）可进一步对S[1。。K-1]和S[K+1。。N]两组数据再进行快速排序直到分组对象只有一个数据为止。
如具体数据如下，那么第一躺快速排序的过程是：
数组下标： 1 2 3 4 5 6 7 8 9 10
45 36 18 53 72 30 48 93 15 36
（1） 36 36 18 53 72 30 48 93 15 45
（2） 36 36 18 45 72 30 48 93 15 53
（3） 36 36 18 15 72 30 48 93 45 53
（4） 36 36 18 15 45 30 48 93 72 53
（5） 36 36 18 15 30 45 48 93 72 53
( Mon, 25 Jan 2010 12:28:41 +0800 )
Description:
public cla Num2ChsBig
{ public static String changeToBig(double value) { char[] hunit = {'拾', '佰', '仟'}; // 段内位置表示 char[] vunit = {'万', '亿'}; // 段名表示 char[] digit = {'零', '壹', '贰', '叁', '肆', '伍', '陆', '柒', '捌', '玖'}; // 数字表示 long midVal = (long) (value * 100); // 转化成整形 String valStr = String.valueOf(midVal); // 转化成字符串 String head = valStr.su tring(0, valStr.length() - 2); // 取整数部分 String rail = valStr.su tring(valStr.length() - 2); // 取小数部分 String prefix = ""; // 整数部分转化的结果 String suffix = ""; // 小数部分转化的结果 // 处理小数点后面的数 if (rail.equals("00")) { // 如果小数部分为0 suffix = "整"; } else { suffix = digit[rail.charAt(0) - '0'] + "角" + digit[rail.charAt(1) - '0'] + "分"; // 否则把角分转化出来 } // 处理小数点前面的数 char[] chDig = head.toCharArray(); // 把整数部分转化成字符数组 char zero = '0'; // 标志'0'表示出现过0 byte zeroSerNum = 0; // 连续出现0的次数 for (int i = 0; i chDig.length; i++) { // 循环处理每个数字 int idx = (chDig.length - i - 1) % 4; // 取段内位置 int vidx = (chDig.length - i - 1) / 4; // 取段位置 if (chDig[i] == '0') { // 如果当前字符是0 zeroSerNum++; // 连续0次数递增 if (zero == '0') { // 标志 zero = digit[0]; } else if (idx == 0 &am am vidx 0 &am am zeroSerNum 4) { prefix += vunit[vidx - 1]; zero = '0'; } continue; } zeroSerNum = 0; // 连续0次数清零 if (zero != '0') { // 如果标志不为0,则加上,例如万,亿什么的 prefix += zero; zero = '0'; } prefix += digit[chDig[i] - '0']; // 转化该数字表示 if (idx 0) prefix += hunit[idx - 1]; if (idx == 0 &am am vidx 0) { prefix += vunit[vidx - 1]; // 段结束位置应该加上段名如万,亿 } } if (prefix.length() 0) prefix += '圆'; // 如果整数部分存在,则有圆的字样 return prefix + suffix; // 返回正确表示 }
( Mon, 25 Jan 2010 12:05:15 +0800 )
Description:
java中浮点数的计算
今天在数值计算时碰到一个问题.程序如下: double a = (3.3-2.4)/0.1; System.out.println(a);
你可能认为结果很简单,不就是9嘛,是事实上,结果为:8.999999998,为什么呢?我翻阅了一些资料,终于找出了原因.
为什么浮点数会丢失精度？ 十进制数的二进制表示可能不够精确
浮点数或是双精度浮点数无法精确表示的情况并不少见。浮点数值没办法用十进制来精确表示的原因要归咎于CPU表示浮点数的方法。这样的话您就可能会牺牲一些精度，有些浮点数运算也会引入误差。以上面提到的情况为例，2.4的二进制表示并非就是精确的2.4。反而最为接近的二进制表示是 2.3999999999999999。原因在于浮点数由两部分组成：指数和尾数。浮点数的值实际上是由一个特定的数学公式计算得到的。您所遇到的精度损失会在任何操作系统和编程环境中遇到。
注意： 您可以使用Binary Coded Decimal (BCD)库来保持精度。BCD数字编码方法会把每一个十进制数字位单独编码。 类型失配
您可能混合了浮点数和双精度浮点数类型。请确定您在进行数学运算的时候所有的数据类型全部相同。
注意：float类型的变量只有7位的精度，而double类型的变量有15位的精度。
如何进行浮点数精度计算？ Java中的简单浮点数类型float和double不能够进行运算。不光是Java，在其它很多编程语言中也有这样的问题。在大多数情况下，计算的结果是准确的，但是多试几次（可以做一个循环）就可以试出类似上面的错误。现在终于理解为什么要有BCD码了。
这个问题相当严重，如果你有9.999999999999元，你的计算机是不会认为你可以购买10元的商品的。
在有的编程语言中提供了专门的货币类型来处理这种情况，但是Java没有。现在让我们看看如何解决这个问题。 四舍五入
我们的第一个反应是做四舍五入。Math类中的round方法不能设置保留几位小数，我们只能象这样（保留两位）：
public double round(double value){ return Math.round(value*100)/100.0;
非常不幸，上面的代码并不能正常工作，给这个方法传入4.015它将返回4.01而不是4.02，如我们在上面看到的
4.015*100=401.49999999999994
因此如果我们要做到精确的四舍五入，不能利用简单类型做任何运算
java.text.DecimalFormat也不能解决这个问题 ...... 前段时间在做k的项目时，有一些客户端的计算，用js写的。发现了js精度的一些问题，借鉴某位大牛的一句话：“内事不决问百度，外事不决问google”的经典名言，上网淘了下相关资料，总结了下，以供参考：
1、js精度问题产生的根源：
这两个网址上洋洋洒洒说了一大堆，归根结底就是类型的精度问题导致，js的number类型按照ECMA的JavaS
cript标准，它的Number类型就是IEEE 754的双精度数值，相当于java的double类型。
详细的内容可以参考：
http://forum.eaw.com.cn/thread/10/1
http://blog.csdn.net/xiaocon/archive/2005/09/03/470709.a x 2、js精度问题的解决方案： 1）由于js对于整数计算是没有误差的，可以先转化为整数进行计算
MathUtil.js
//浮点数相加
function dcmAdd(arg1,arg2){ var r1,r2,m; try{r1=arg1.toString(). lit(”.”)[1].length;}catch(e){r1=0;} try{r2=arg2.toString(). lit(”.”)[1].length;}catch(e){r2=0;} m=Math.pow(10,Math.max(r1,r2)); return (dcmMul(arg1,m)+dcmMul(arg2,m))/m;
//浮点数相减
function dcmSub(arg1,arg2){ return dcmAdd(arg1,-arg2);
//浮点数相乘
function dcmMul(arg1,arg2){ var m=0,s1=arg1.toString(),s2=arg2.toString(); try{m+=s1. lit(”.”)[1].length;}catch(e){} try{m+=s2. lit(”.”)[1].length;}catch(e){} return Number(s1.replace(”.”,”"))*Number(s2.replace(”.”,”"))/Math.pow(10,m);
//浮点数除
function dcmDiv(arg1,arg2){ return dcmMul(arg1,1/arg2);
} Number.prototype.add = function (arg){ return dcmAdd(this, arg);
Number.prototype.sub = function (arg){ return dcmSub(this, arg);
} Number.prototype.mul = function (arg){ return dcmMul(this, arg);
Number.prototype.div = function (arg){ return dcmDiv(this, arg);
} 2）模拟服务端bigdecimal的实现写一个js客户端的bigdecimal算法 自己写一套客户端的bigdecimal算法或者参考现成的bigdecimal实现 参考网址：http://stz-ida.de/html/o /js_bigdecimal.html.en 3）利用ajax提交到后台进行计算 4）总结： 1、尽量不要用JS做复杂的运算，特别是浮点数的运算。 2、如果一定要进行浮点数的运算的话，先将浮点数转化为整形，再运算。
( Tue, 5 Jan 2010 18:26:30 +0800 )
Description:
当我开始喜欢你，我会这样问你
如果我是你的女朋友，我会每天都跟你说我喜欢你，不为什么就是想亲亲你；
　　如果我是你的女朋友，我会要你拉着我的手过马路，绝对不会看来往的车辆；
　　如果我是你的女朋友，我会亲自帮你挑衣服，挑手链，挑帅帅的牛仔裤，让每个女孩都羡慕我有个好精神的男朋友；
　　如果我是你的女朋友，我会笨手笨脚地给你织全羊毛的淡灰色围巾；
　　如果我是你的女朋友，我会要你带我去看悲剧的电影，出来的时候还在哭，我要你哄我说，那只是电影，我们不会那样的；
　　如果我是你的女朋友，我会在你的哥们儿面前给足你面子，然后背地里跟你算帐；
　　如果我是你的女朋友，我会让自己看上去很漂亮很幸福，不用我说，别人都知道你是绝世好男友；
　　如果我是你的女朋友，我会在打***给你的时候很礼貌地和你的父母打招呼，希望他们会对我留下好印象；
　　如果我是你的女朋友，我会要你给我买很便宜但是很特别的戒指，我会把两个带着情侣戒指的手拉到一起，边看边傻笑很久；
　　如果我是你的女朋友，我会鼓励你做你喜欢的事情，而不要只为了学习或责任束缚自己的梦想，因为人生短短一瞬，快乐最重要；
　　如果我是你的女朋友，我不会阻止你有节制地玩电脑游戏
，我也会以当匪首老婆为奋斗目标，帮你偷看旁边的***溜到了
区还是
　　如果我是你的女朋友，我会希望有来世，让我还做你的女朋友；
　　如果我是你的女朋友
　　可以吗？
当我确定我爱你，我会这样问你
有一天
我们可不可以这样相爱
　　约定好每一个彼此都想去的地方
　　然后一个一个的慢慢实现
　　在每一个景点
　　拍下两人紧握的双手
　　有一天
我们可不可以这样相爱
　　一个人哼起一段旋律
　　另一个人什么也不说
　　只是轻轻唱出下一句
　　有一天
我们可不可以这样相爱
　　畅想未来生活时
　　可以惊愕地发现
　　心中构筑的小家
　　有着同样的风景
　　有一天
我们可不可以这样相爱
　　不经意做了让对方为难的事情
　　抱歉地流泪
　　而另一个人什么也不说
　　只是静静的把哭泣的人搂在怀里
　　有一天
我们可不可以这样相爱
　　当异性走来时
　　只是微笑的掏出钱夹里两人的合影
　　轻轻的说一句
对不起
我已经有了要守候的人
　　有一天
我们可不可以这样相爱
　　面对纷纷扰扰的尘嚣
　　心里却很确定
　　想和眼前的人过好每一天
　　有一天
我们可不可以这样相爱
　　不去担心会不会失去彼此
　　却在心底无比确定不能失去彼此
　　不去想这段感情能活多长时间
　　却在心里将永远视为理想期限
　　有一天
我们可不可以这样相爱
　　心中的
我爱你
　　像太阳从东方升起
　　像人类生存需要呼吸
　　一样自然和必须
　　如果有一天
我们可以这样相爱
　　我想每天早起拉开窗帘迎接阳光
　　收拾狭小且凌乱的房间
　　做简单却拿手的煎蛋
　　洗去一身油烟味
　　轻轻走过去摇醒睡在大床上的那个人
　　如果有一天
我们可以这样相爱
　　我想在你心情不好的时候
　　保持沉默的同时
　　把你的头静静的搂在怀里
　　拍拍你的肩
　　让你知道不快总会过去
　　如果有一天
我们可以这样相爱
　　我想在家里亮一盏灯
　　等候加班晚归的你
　　在你掏出钥匙的一刻
　　穿着围裙为你打开大门
　　让你看到笑笑的我
　　和一桌不丰盛却热气腾腾的饭菜
　　如果有一天
我们可以这样相爱
　　我想在某个争吵冷战的夜里
　　向你这样妥协
我们都承认我对了
我们都承认你错了
　　等你无奈又无语的摸摸我的头
　　轻轻的抱抱我
　　如果有一天
我们可以这样相爱
　　我想我再也不会选择离开
　　无论身旁的你在或者不在
当我被你伤了心，我会这样问你
如果有一天我不再烦你，你会想我吗？
　　某一天，你的耳边不再有人说烦人，讨厌。不再有人固执的说自己永远是正确的，不再有人粗鲁的对你发脾气。不再有人和你讨价还价的想多讲几分钟***，不再有人在挂***之前吵着要你亲亲和抱抱。这样的一个我消失了，你会难过吗？
　　某一天，你的短信收件箱里，不再有人可怜兮兮的说距离你回家还有几分几秒，不再有人恶狠狠的说再不和我说话我就揍你啦，不再有人撒娇的说你讨厌说你坏，不再有人在做错事情之后悔恨不已的责备自己不对。不再有人胡言乱语，不再有人长嘘短叹，不再有人时而温顺的对你言听计从，又突然大呼小喝的对你乱发脾气。你失去了这样的一个我，会失落吗？
　　某一天，你的想象中不再有人无论是深夜还是白天都坐在电脑旁等待着你回家，等待着可以打***给你的时间，这样的一个我离开了，你会想我吗？
　　真的到了那样的一天，我还是希望你有一点点的难过，一点点的失落，一点点的想我，只要有一点点关于我的记忆就好，真的只要一点点就好。
而亲爱的，我希望你能了解
男人永远也不知道女人为什么那么在乎他有没有来***和短信。
　　因为她们自己知道
其实并不一定要那些甜言蜜语
只要你无论多忙都会想着她就行了
　　男人永远也不知道女人为什么总在生气时闹着要分手。
　　因为她们自己知道
她们并不是真的想分手只是想你去挽留她
从而找到被爱的证据
　　男人永远也不知道女人为什么要在分手以后还会对他嘘寒问暖。
　　因为她们自己知道
她们并不是想跟你做朋友
只是想挽回这段曾经属于她的感情
　　男人永远也不知道女人为什么在分手以后会夜夜痛哭。
　　因为她们知道
如果今晚不用哭来麻醉自己
那么今晚只能在思念中度过
　　男人永远也不知道女人为什么会那么爱对他发脾气。
　　因为她们自己知道
对他发脾气并不是不爱她
只是非常非常的在乎他
希望他更完美
　　男人永远也不知道女人为什么会那么在意你以前的女朋友。
　　因为她们自己知道
并不完全是她们不自信
只是她们害怕有一天你会离他而去
而亲爱的，我希望你会做到
如果她做错了事，心里已经很难过，请主动承担起你应该甚至不应该承担的责任吧。
　　把她的照片帖到钱包，手机
一切经常看到的地方。
　　离开她绝对不超过十天以上。
　　不要老是在她问你
去那里比较好
吃什么
等等的时候说
，这不等于是你在迁就她，只表示你没有心思搭理她。
　　要经常对她说
我爱你
，否则她会假设你不爱她。
　　永远不要在公众场合对她呼呼吼吼又或是撇下她一人。
　　她做错事情的时候教训她不要紧，最重要的是在那之后要哄她。
　　发脾气时不要不理她，不要给时间她让她冷静，其实她完全不需要时间冷静。
　　在她想你时，争分夺秒地挤出时间与她约会。
　　看她的眼神无比专注。
　　能做到客观的得看到其它优秀的女孩，但主观认为她才是最好的。
　　有女孩和你说话，你要拉着她的手，如果她恰巧不在旁边，那么请你跟她们保持距离。
　　过马路的时候牵着她的手。
　　要懂得珍惜和她在一起的每分钟。
　　就算再忙，每天都不忘打一个问候的***。
　　要常常唱情歌给她听。
　　即使全世界的人都不相信她，你也要无条件相信她。因为她也会同样对你。
　　她穿了好看的衣服，你要衷心赞美。
　　在她心情遭透，蛮横发脾气的时候，抱抱她，而不是和她理论。
　　希望不会出现手机没电而她又没有其它办法联系到你的现象，如果能频频主动打***告诉她
我想你了
并随时汇报行踪则更好。
　　她身上有很多缺点，她已经够苦恼了，请不必随时向她提醒。
　　女友不讲理是撒娇而不是撒野。
　　她所有的事情都好想跟你分享、虽然你不一定会明白但是希望你会装做你在听。
而亲爱的，你一定要知道的是
我要的是一个全心全意爱我的你，而你拥有的，是一个死心塌地爱你的我。
( Tue, 5 Jan 2010 18:25:01 +0800 )
Description:
我要好好计划计划了！ 该怎么提升自己！仔细想想!
( Wed, 30 Dec 2009 17:02:58 +0800 )
Description: 真正的感情根本不需要追的。两个人的默契，在慢慢将两颗心的距离缩短，在无意识中渐渐靠近彼此。从好朋友到情人，真正的感情是用不了多久的。从你喜欢上他的那一刻起，也许他也在那一刻喜欢上了你。同节奏的爱情往往能奏出最和谐最动听的乐章。真正的爱情需要什么？需要两个人在一起是轻松快乐的，没有压力。 爱一个人就是毫无保留地付出吗？ 不是。每一个人都是一个独立的人，我们首先是属于自己的，我们有思想，我们有个性，而不是把我们的全部都给对方。我们可以有保留，比如你不愿意说的隐私，有秘密的人才是成熟的，不是吗？有时候不说出来反而更好。 外貌和个性哪个更重要？ 男人年轻的时候往往喜欢漂亮