线程总结

每条进程：

Thread.yield()：释放所有进程，让所有进程重新进行竞争

Thread.sleep()：进行让进程进行暂停一定时间，时间到后，主动完成接下来未完成的，可以让别的进程的优先级提升

Thread.join()：让其他进程为该进程让路，直到该进程处理完了后，其他进程才进行操作

sleep是主动的自发的，wait是命令下达的

多条进程竞争：

Object.wait()：将进程从运行的队伍中拉出来，是被动的，当notify()方法的时候，在去进行接下来未完成的处理

Object.notify()：要求随机的一个等待中的线程，进行接下未完成的处理的命令

Object.notifyAll()：要求等待中的线程都去做未完成的处理，这些进程都会从Wait Set出来，但这些进程，究竟是哪个进入Critical
Section，最终还是要靠各自的竞争，进行接下未完成的处理的命令

多进程时，synchronized保证互斥性，wait()/notify()/notifyAll()保证同步性

方式：

synchronized

①

1. public synchronized void synMethod(){
2. 　　//方法体
3. 　　}

②

1. public Object synMethod(Object a1){
2. 　　synchronized(a1){
3. 　　//一次只能有一个线程进入
4. 　　}
5. 　　}

synchronized后面括号里是一对象,此时,线程获得的是对象锁

Object a1使用this和虚拟对象的区别：

1. public class MyThread implements Runnable{
2. 　　public static void main(Stringargs[]){
3. 　　MyThread mt=new MyThread();
4. 　　Thread t1=newThread(mt,"t1");
5. 　　Thread t2=newThread(mt,"t2");
6. 　　Thread t3=newThread(mt,"t3");
7. 　　Thread t4=newThread(mt,"t4");
8. 　　Thread t5=newThread(mt,"t5");
9. 　　Thread t6=newThread(mt,"t6");
10. 　　t1.start();
11. 　　t2.start();
12. 　　t3.start();
13. 　　t4.start();
14. 　　t5.start();
15. 　　t6.start();
16. 　　}
17. 　　public void run(){
18. 　　synchronized(this){
19. 　　System.out.println(Thread.currentThread().getName());
20. 　　}
21. 　　}
22. 　　}

1. class FineGrainLock{
2. 　　MyMemberClassx,y;
3. 　　Object xlock = new Object();
4. 　　public void foo(){
5. 　　synchronized(xlock){
6. 　　//accessxhere
7. 　　}
8. 　　//dosomethinghere-butdon‘tusesharedresources
9. 　　}
10. }

首先这两则都会可以得到对象锁，使用this时（对整个对象上锁），如果线程进入,则得到当前对象锁,那么别的线程在该类所有对象上的任何操作都不能进行。如果一个对象拥有多个资源，就不需要只为了让一个线程使用其中一部分资源，就将所有线程都锁在外面。由于每个对象都有锁，使用虚拟对象就可以解决这个问题。

竞争过程

①、一个进程，进入Critical Section中，紧接着就会给他上一个锁（导致其他进程不能进来，达到排斥性），让其进行相应的Run处理

②、当达到某种自己设定条件时候，调用了wait()方法后，则该进程就被从Critical Section放到Wait Set中（让其等待），同时，他的锁也被解锁了

③、这个时候，另外的进程就竞争进入Critical Section中（最终只有一条进程进入，并且进入后就上锁），如果他满足②中的设定条件他也将调用了wait()方法，进入Wait
Set。反之，则会遇到notify()或者notifyAll()，去释放Wait Set中的进程