Java的Thread线程操作

线程是一个程序的多个执行路径，执行调度的单位，依托于进程存在。 线程不仅可以共享进程的内存，而且还拥有一个属于自己的内存空间，这段内存空间也叫做线程栈，是在建立线程时由系统分配的，主要用来保存线程内部所使用的数据，如线程执行函数中所定义的变量。

注意：Java中的多线程是一种抢占机制而不是分时机制。抢占机制指的是有多个线程处于可运行状态，但是只允许一个线程在运行，他们通过竞争的方式抢占CPU。

 

ThreadTest1 tt = new
 ThreadTest1();
tt.start();

ThreadTest2 tt = new
 ThreadTest2();
Thread t = new
 Thread(tt);
t.start();

1）优先级（priority）

每个类都有自己的优先级，一般property用1-10的整数表示，默认优先级是5，优先级最高是10；优先级高的线程并不一定比优先级低的线程执行的机会高，只是执行的机率高；默认一个线程的优先级和创建他的线程优先级相同；

2）Thread.sleep()/sleep(long millis)

当前线程睡眠/millis的时间（millis指定睡眠时间是其最小的不执行时间，因为sleep(millis)休眠到达后，无法保证会被JVM立即调度）；sleep()是一个静态方法(static method) ，所以他不会停止其他的线程也处于休眠状态；线程sleep()时不会失去拥有的对象锁。 作用：保持对象锁，让出CPU，调用目的是不让当前线程独自霸占该进程所获取的CPU资源，以留一定的时间给其他线程执行的机会；

3）Thread.yield()

让出CPU的使用权，给其他线程执行机会、让同等优先权的线程运行。yield不能破死锁，因为不会交出资源的同步锁。yield也并不保证当前线程会被JVM再次调度：即yield之后使该线程可能立刻重新被分配CPU资源并进入Running状态。如果没有同等优先权的线程，那么yield()方法将不会起作用。

4）thread.join()

使用该方法的线程会在此之间执行完毕后再往下继续执行:

t.join();            //调用join方法，等待线程t执行完毕

this.join();      //同一进程中，等待当前线程的.run()中的任务执行完毕，再执行该句之后的任务

5）object.wait()

当一个线程执行到wait()方法时，他就进入到一个和该对象相关的等待池(Waiting Pool)中，同时失去了对象的机锁—暂时的，wait后还要返还对象锁。当前线程必须拥有当前对象的锁，如果当前线程不是此锁的拥有者，会抛出IllegalMonitorStateException异常,所以wait()必须在synchronized block中调用。如果没有匹配的notify，wait会一直等待。另需注意，notify/wait如果一般分属两个线程，如果notify先于wait执行，则会导致wait一直阻塞，影响既定设计。此时，可以interrupt立刻唤醒并终止永久阻塞的该线程，不过会有异常抛出。

6）object.notify()/notifyAll()

唤醒在当前对象等待池中等待的第一个线程/所有线程。notify()/notifyAll()也必须拥有相同对象锁，否则也会抛出IllegalMonitorStateException异常。 特别注意，当执行notify/notifyAll方法时，会唤醒一个处于等待该“对象锁”的线程，然后继续往下执行，直到执行完退出对象锁锁住的区域（synchronized修饰的代码块）后再释放锁。因此一般执行完notify后应立刻结束当前进程。

7）Synchronizing Block

Synchronized Block/方法 控制对类成员变量的访问；Java中的每一个对象都有唯一的一个内置的锁，每个Synchronized Block/方法只有持有调用该方法被锁定对象的锁才可以访问 ，否则所属线程阻塞； 机锁具有独占性、一旦被一个Thread持有，其他的Thread就不能再拥有（不能访问其他同步方法）， 方法一旦执行，就独占该锁，直到从该方法返回时才将锁释放，此后被阻塞的线程方能获得该锁，重新进入可执行状态。

1. 当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。
2. 然而，当一个线程访问object的一个synchronized(this)同步代码块时，另一个线程仍然可以访问该object中的非synchronized(this)同步代码块。
3. 尤其关键的是，当一个线程访问object的一个synchronized(this)同步代码块时，其他线程对object中所有其它synchronized(this)同步代码块的访问将被阻塞。即，只要在synchronized(this)模块中的代码，就是是割裂的，也被视为一个整体。
4. 第三个例子同样适用其它同步代码块。也就是说，当一个线程访问object的一个synchronized(this)同步代码块时，它就获得了这个object的对象锁。结果，其它线程对该object对象所有同步代码部分的访问都被暂时阻塞。即，如果非同步代码块，而是以修饰符的形式出现在Method上，同样被视为一个整体。
5. 以上规则对其它对象锁同样适用。总结下来就是一句话，只要被synchronized修饰，就是同一家子。同一时间只能有一个线程访问这家。

举例说明：

public class Thread1 implements Runnable {
public void run() {
synchronized(this) {
for (int i = 0; i < 5; i++) {
System.out.println(Thread.currentThread().getName() + " synchronized loop " + i);
}
}  //End of Block
}
public static void main(String[] args) {
Thread1 t1 = new Thread1();
Thread ta = new Thread(t1, "A");
Thread tb = new Thread(t1, "B");
ta.start();
tb.start();
}
}

结果：
A synchronized loop 0
A synchronized loop 1
A synchronized loop 2
A synchronized loop 3
A synchronized loop 4
B synchronized loop 0
B synchronized loop 1
B synchronized loop 2
B synchronized loop 3
B synchronized loop 4