java线程

java线程具有五中基本状态

新建状态（New）：当线程对象对创建后，即进入了新建状态，如：Thread t = new MyThread();

就绪状态（Runnable）：当调用线程对象的start()方法（t.start();），线程即进入就绪状态。处于就绪状态的线程，只是说明此线程已经做好了准备，随时等待CPU调度执行，并不是说执行了t.start()此线程立即就会执行；

运行状态（Running）：当CPU开始调度处于就绪状态的线程时，此时线程才得以真正执行，即进入到运行状态。注：就     绪状态是进入到运行状态的唯一入口，也就是说，线程要想进入运行状态执行，首先必须处于就绪状态中；

阻塞状态（Blocked）：处于运行状态中的线程由于某种原因，暂时放弃对CPU的使用权，停止执行，此时进入阻塞状态，直到其进入到就绪状态，才 有机会再次被CPU调用以进入到运行状态。根据阻塞产生的原因不同，阻塞状态又可以分为三种：

1.等待阻塞：运行状态中的线程执行wait()方法，使本线程进入到等待阻塞状态；

2.同步阻塞 -- 线程在获取synchronized同步锁失败(因为锁被其它线程所占用)，它会进入同步阻塞状态；

3.其他阻塞 -- 通过调用线程的sleep()或join()或发出了I/O请求时，线程会进入到阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。

死亡状态（Dead）：线程执行完了或者因异常退出了run()方法，该线程结束生命周期。

 Java多线程的创建和启动

继承Thread类，重写run()方法

package com.minimax;

public class MyThread extends Thread {
	private int i = 0;
	public void run() {
		for (i = 0; i < 100; i++) {
			System.out.println(Thread.currentThread().getName() + " " + i);
		}
	}
}

 

package com.minimax;

public class TestThread {
	public static void main(String[] args) {
		for (int i = 0; i < 100; i++) {
			System.out.println(Thread.currentThread().getName() + " " + i);
			if (i == 30) {
				Thread myThread1 = new MyThread(); // 创建一个新的线程 myThread1此线程进入新建状态
				Thread myThread2 = new MyThread(); // 创建一个新的线程 myThread2此线程进入新建状态
				myThread1.start(); // 调用start()方法使得线程进入就绪状态
				myThread2.start(); // 调用start()方法使得线程进入就绪状态
			}
		}

	}
}

 实现Runnable接口，并重写该接口的run()方法，

package com.minimax;

public class MyRunnable implements Runnable {
	private int i = 0;
	@Override
	public void run() {
		for (i = 0; i < 100; i++) {
			System.out.println(Thread.currentThread().getName() + " " + i);
		}
	}
}

package com.minimax;

public class TestThread {
	public static void main(String[] args) {
		for (int i = 0; i < 100; i++) {
			System.out.println(Thread.currentThread().getName() + " " + i);
			if (i == 30) {
				Runnable myRunnable = new MyRunnable();
				Thread thread1 = new Thread(myRunnable);
				Thread thread2 = new Thread(myRunnable);
				thread1.start();
				thread2.start();
			}
		}
	}
}

实现Runnable接口比继承Thread类所具有的优势：

• 适合多个相同的程序代码的线程去处理同一个资源
• 可以避免java中的单继承的限制
• 增加程序的健壮性，代码可以被多个线程共享，代码和数据独立
• 线程池只能放入实现Runable或callable类线程，不能直接放入继承Thread的类

线程的调度

 

调整线程优先级：Java线程有优先级，优先级高的线程会获得较多的运行机会。
Java线程的优先级用整数表示，取值范围是1~10，Thread类有以下三个静态常量：

public final static int MIN_PRIORITY = 1;  // 线程可以具有的最低优先级，取值为1。
public final static int NORM_PRIORITY = 5; // 分配给线程的默认优先级，取值为5。
public final static int MAX_PRIORITY = 10; // 线程可以具有的最高优先级，取值为10。

Thread类的setPriority()和getPriority()方法分别用来设置和获取线程的优先级。
 每个线程都有默认的优先级。主线程的默认优先级为Thread.NORM_PRIORITY。
线程的优先级有继承关系，比如A线程中创建了B线程，那么B将和A具有相同的优先级。

线程睡眠：Thread.sleep(long millis)方法，使线程转到阻塞状态。millis参数设定睡眠的时间，以毫秒为单位。当睡眠结束后，就转为就绪（Runnable）状态。sleep()平台移植性好。
线程等待：Object类中的wait()方法，导致当前的线程等待，直到其他线程调用此对象的 notify() 方法或 notifyAll() 唤醒方法。这个两个唤醒方法也是Object类中的方法，行为等价于调用 wait(0) 一样。
线程让步：Thread.yield() 方法，暂停当前正在执行的线程对象，把执行机会让给相同或者更高优先级的线程。
线程加入：join()方法，等待其他线程终止。在当前线程中调用另一个线程的join()方法，则当前线程转入阻塞状态，直到另一个进程运行结束，当前线程再由阻塞转为就绪状态。
 线程唤醒：Object类中的notify()方法，唤醒在此对象监视器上等待的单个线程。如果所有线程都在此对象上等待，则会选择唤醒其中一个线程。选择是任意性的，并在对实现做出决定时发生。线程通过调用其中一个 wait 方法，在对象的监视器上等待。 直到当前的线程放弃此对象上的锁定，才能继续执行被唤醒的线程。被唤醒的线程将以常规方式与在该对象上主动同步的其他所有线程进行竞争；例如，唤醒的线程在作为锁定此对象的下一个线程方面没有可靠的特权或劣势。类似的方法还有一个notifyAll()，唤醒在此对象监视器上等待的所有线程。
 

wait和sleep区别

共同点：

• 他们都是在多线程的环境下，都可以在程序的调用处阻塞指定的毫秒数，并返回。
• wait()和sleep()都可以通过interrupt()方法 打断线程的暂停状态 ，从而使线程立刻抛出InterruptedException。

   如果线程A希望立即结束线程B，则可以对线程B对应的Thread实例调用interrupt方法。如果此刻线程B正在wait/sleep /join，则线程B会立刻抛出InterruptedException，在catch() {} 中直接return即可安全地结束线程。
   需要注意的是，InterruptedException是线程自己从内部抛出的，并不是interrupt()方法抛出的。对某一线程调用 interrupt()时，如果该线程正在执行普通的代码，那么该线程根本就不会抛出InterruptedException。但是，一旦该线程进入到 wait()/sleep()/join()后，就会立刻抛出InterruptedException 。
不同点：

•  Thread类的方法：sleep(),yield()等 .Object的方法：wait()和notify()等
• 每个对象都有一个锁来控制同步访问。Synchronized关键字可以和对象的锁交互，来实现线程的同步。 sleep方法没有释放锁，而wait方法释放了锁，使得其他线程可以使用同步控制块或者方法。
• wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，而sleep可以在任何地方使用
• sleep必须捕获异常，而wait，notify和notifyAll不需要捕获异常

所以sleep()和wait()方法的最大区别是：
sleep()睡眠时，保持对象锁，仍然占有该锁；
而wait()睡眠时，释放对象锁。
但是wait()和sleep()都可以通过interrupt()方法打断线程的暂停状态，从而使线程立刻抛出InterruptedException（但不建议使用该方法）。
sleep（）方法
sleep()使当前线程进入停滞状态（阻塞当前线程），让出CUP的使用、目的是不让当前线程独自霸占该进程所获的CPU资源，以留一定时间给其他线程执行的机会;
sleep()是Thread类的Static(静态)的方法；因此他不能改变对象的机锁，所以当在一个Synchronized块中调用Sleep()方法是，线程虽然休眠了，但是对象的机锁并木有被释放，其他线程无法访问这个对象（即使睡着也持有对象锁）。
在sleep()休眠时间期满后，该线程不一定会立即执行，这是因为其它线程可能正在运行而且没有被调度为放弃执行，除非此线程具有更高的优先级。
wait（）方法
wait()方法是Object类里的方法；当一个线程执行到wait()方法时，它就进入到一个和该对象相关的等待池中，同时失去（释放）了对象的机锁（暂时失去机锁，wait(long timeout)超时时间到后还需要返还对象锁）；其他线程可以访问；
wait()使用notify或者notifyAlll或者指定睡眠时间来唤醒当前等待池中的线程。
wiat()必须放在synchronized block中，否则会在program runtime时扔出”java.lang.IllegalMonitorStateException“异常。

 线程同步

synchronized 关键字

在java中，每一个对象都有一个对象锁与之相关联，该锁表明对象在任何时候只允许被一个线程所拥有，当一个线程调用对象的一段synchronized代码时，首先需要获得这个锁，然后去执行相应的代码，执行结束后，释放锁。

synchronized关键字主要有两种使用方式（synchronized方法和synchronized代码块），此关键字还可以运用于静态方法、类或某一个实例，但是对程序的效率影响很大。

synchronized方法

public synchronized void mutiThreadAccess();

只要把多个线程访问的资源操作放到mutiThreadAccess方法中，就能够保证这个方法在同一刻只能被一个线程来访问，从而保证了多个线程访问的安全性。然而，当一个方法的方法体规模非常大的时候会影响程序执行效率。所以提供了synchronized代码块。

synchronized代码块

可以把任意的代码段申明为synchronized，也可以指定上锁的对象，有非常高的灵活性，

synchronized （syncObject）{
    //访问同步代码
}

wait与notify

当使用synchronized来修饰某一个共享资源时候，如果线程A1在执行synchronized代码，另外一个线程A2也要同时执行同一对象的同一synchronized代码时，线程A2将要等到线程A1执行完毕后才能执行。在这种情况下，可以使用wait方法和notify方法。

在synchronized代码执行期间，线程可以调用对象的wait方法，释放对象锁，进入等待状态，并且可以调用notify方法或notifyAll方法通知正在等待的其他线程，notify方法
仅唤醒一个线程（等待队列中的第一个线程），并允许它去获得锁，而notifyAll方法唤醒所有等待这个对象的线程，并允许他们去获得锁（并不是让所有唤醒的线程都获得锁，而是让他们去竞争）；

死锁

当1号线程执行过程中使用（锁定）对象A，同时还需要使用（锁定）另一个对象B。但是2号线程使用（锁定）了对象B，同时还需要使用（锁定）对象A。

这种情况导致 1号线程等待2号线程执行完才能继续执行；2号线程等待1号线程的执行完才能继续执行。即1号线程、2号线程均无法继续执行；其他线程无法所得资源，也无法继续执行。整个程序无法继续执行。即死锁。

package com.minimax;

public class TestDeadLock implements Runnable {
	    public int flag = 1;
	    static Object o1 = new Object(), o2 = new Object();
	    public void run() {
	        System.out.println("flag=" + flag);
	        if (flag == 1) {
	            synchronized (o1) { // 线程锁住o1。
	                try {
	                    Thread.sleep(500);
	                } catch (Exception e) {
	                    e.printStackTrace();
	                }
	                synchronized (o2) { // 线程锁住o2。
	                    System.out.println("1");
	                }
	            }
	        }
	        if (flag == 0) {
	            synchronized (o2) { // 线程锁住o2。
	                try {
	                    Thread.sleep(500);
	                } catch (Exception e) {
	                    e.printStackTrace();
	                }
	                synchronized (o1) { // 线程锁住o1。
	                    System.out.println("0");
	                }
	            }
	        }
	    }
}

 

package com.minimax;

public class TestThread {

    public static void main(String[] args) {
        TestDeadLock td1 = new TestDeadLock();
        TestDeadLock td2 = new TestDeadLock();
        td1.flag = 1;
        td2.flag = 0;
        Thread t1 = new Thread(td1); // flag1线程。
        Thread t2 = new Thread(td2); // flag2线程。
        t1.start();
        t2.start();
    }
}