多线程

1. 有两种方法可以创建并运行一个线程：继承Thread类并覆盖Run方法，Run中的代码就在另一个线程执行。

view plaincopy to clipboardprint?class MyThread extends Thread {MyThread() {// 调用下面代码，线程开始运行start();}@Overridepublic void run() {// 这里的代码是在线程中执行的int i = 0;while (i < 20){System.out.println(i);try {sleep(100);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}++i;}}}public class Main {public static void main(String[] args) {MyThread myThread = new MyThread();}}class MyThread extends Thread {MyThread() {// 调用下面代码，线程开始运行start();}@Overridepublic void run() {// 这里的代码是在线程中执行的int i = 0;while (i < 20){System.out.println(i);try {sleep(100);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}++i;}}}public class Main {public static void main(String[] args) {MyThread myThread = new MyThread();}}实现Runnable接口并传给新建的Thread类，实现类的Run方法即在另一个线程执行。

view plaincopy to clipboardprint?// 实现Runnable接口public class Main implements Runnable {@Overridepublic void run() {// 这里的代码是在线程中执行的int i = 0;while (i < 20){System.out.println(i);try {Thread.sleep(100);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}++i;}}public static void main(String[] args) { Main runable = new Main();new Thread(runable).start();}}// 实现Runnable接口public class Main implements Runnable { @Overridepublic void run() {// 这里的代码是在线程中执行的int i = 0;while (i < 20){System.out.println(i);try {Thread.sleep(100);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}++i;}}public static void main(String[] args) {Main runable = new Main();new Thread(runable).start();}}2. 后台线程(daemon)不属于程序不可或缺的一部分，当程序存在非后台线程时，程序就不会终止；而如果非后台线程都结束了，此时不管有没有后台线程，程序都可以随时终止。

要设定一个线程为后台线程，可以调用Thread.setDaemon(true)，在一个后台线程中创建其他线程，这些线程也自动被设为后台线程:view plaincopy to clipboardprint?class MyThread extends Thread {MyThread() {// 把该线程设为后台线程setDaemon(true);// 调用下面代码，线程开始运行start();}@Overridepublic void run() {// 这里的代码是在线程中执行的int i = 0;while (i < 20){System.out.println(i);try {sleep(100);} catch (InterruptedException e) {e.printStackTrace();}++i;}}}public class Main{public static void main(String[] args) {MyThread mythread = new MyThread();// mythread.run还没有执行完就结束程序了}}// 程序只打印了0就结束了，而前面的例子程序会打印到19为止class MyThread extends Thread {MyThread() {// 把该线程设为后台线程setDaemon(true);// 调用下面代码，线程开始运行start();}@Overridepublic void run() {// 这里的代码是在线程中执行的int i = 0;while (i < 20){System.out.println(i);try {sleep(100);} catch (InterruptedException e) {e.printStackTrace();}++i;}}}public class Main{public static void main(String[] args) {MyThread mythread = new MyThread();// mythread.run还没有执行完就结束程序了}}// 程序只打印了0就结束了，而前面的例子程序会打印到19为止3. 在上面的例子中，如何让主线程等到后台线程结束时才结束呢？答案是调用后台线程的jion()方法，可以传入一个超时参数，如果不传则表示一直等到后台线程结束才返回：view plaincopy to clipboardprint?class MyThread extends Thread {MyThread() {// 把该线程设为后台线程setDaemon(true);// 调用下面代码，线程开始运行start();}@Overridepublic void run() {// 这里的代码是在线程中执行的int i = 0;while (i < 20){System.out.println(i);try {sleep(100);} catch (InterruptedException e) {e.printStackTrace();}++i;}}}public class Main{public static void main(String[] args) { MyThread mythread = new MyThread(); try {// 等待后台线程结束mythread.join();} catch (InterruptedException e) {e.printStackTrace();}}}class MyThread extends Thread { MyThread() {// 把该线程设为后台线程setDaemon(true);// 调用下面代码，线程开始运行start();}@Overridepublic void run() {// 这里的代码是在线程中执行的int i = 0;while (i < 20){System.out.println(i);try {sleep(100);} catch (InterruptedException e) {e.printStackTrace();}++i;}}}public class Main{public static void main(String[] args) {MyThread mythread = new MyThread();try {// 等待后台线程结束mythread.join();} catch (InterruptedException e) {e.printStackTrace();}}}4. 当两个线程同时读写同一份数据时，可能会引起资源冲突，这时就需要在并行机制之外，再提供一种同步机制，使对数据的读写可以有序的进行，Java对此的处理非常简单，就是使用synchronized关键字：在普通方法前面加上synchronized，使得这个方法变成同步方法，先看下面例子，当主线程和工作线程同时调用synProc时，谁先调用到，谁就获得一个锁，另外一个只能等待，这样就保持在多线程环境下调用这个方法是有序的：view plaincopy to clipboardprint?class MyThread extends Thread {MyThread() {start();}@Overridepublic void run() {synProc();}synchronized public void synProc(){int count = 0;while (count++ < 10) {try {sleep(100);System.out.println("synProc: " + count); } catch (InterruptedException e) {e.printStackTrace();}}}}public class Main{public static void main(String[] args) { MyThread thread = new MyThread(); thread.synProc();}}// 输出结果是：synProc: 1synProc: 2synProc: 3synProc: 4synProc: 5synProc: 6synProc: 7synProc: 8synProc: 9synProc: 10synProc: 1synProc: 2synProc: 3synProc: 4synProc: 5synProc: 6synProc: 7synProc: 8synProc: 9synProc: 10class MyThread extends Thread { MyThread() {start();}@Overridepublic void run() {synProc();}synchronized public void synProc(){int count = 0;while (count++ < 10) {try {sleep(100);System.out.println("synProc: " + count); } catch (InterruptedException e) {e.printStackTrace();}}}}public class Main{public static void main(String[] args) { MyThread thread = new MyThread(); thread.synProc();}}// 输出结果是：synProc: 1synProc: 2synProc: 3synProc: 4synProc: 5synProc: 6synProc: 7synProc: 8synProc: 9synProc: 10synProc: 1synProc: 2synProc: 3synProc: 4synProc: 5synProc: 6synProc: 7synProc: 8synProc: 9synProc: 10其实synchronized方法是在对象级别上的，每个对象都有一个锁，当调用它的任意一个同步方法时，就是去获得这个对象锁，当获得对象锁时，其他同步方法也不能同时被调用了，只能等这个方法执行完才可以被调用，下面代码清楚地说明这一点：view plaincopy to clipboardprint?class MyThread extends Thread {MyThread() {start();}@Overridepublic void run() {synProc();}synchronized public void synProc(){int count = 0;while (count++ < 10) {try {sleep(100);System.out.println("synProc: " + count); } catch (InterruptedException e) {e.printStackTrace();}}}synchronized public void synProc2() { int count = 0;while (count++ < 10) {try {sleep(100);System.out.println("synProc2: " + count); } catch (InterruptedException e) {e.printStackTrace();}}}}public class Main{public static void main(String[] args) { MyThread thread = new MyThread(); thread.synProc2();}}// 输出synProc2: 1synProc2: 2synProc2: 3synProc2: 4synProc2: 5synProc2: 6synProc2: 7synProc2: 8synProc2: 9synProc2: 10synProc: 1synProc: 2synProc: 3synProc: 4synProc: 5synProc: 6synProc: 7synProc: 8synProc: 9synProc: 10class MyThread extends Thread { MyThread() {start();}@Overridepublic void run() {synProc();}synchronized public void synProc(){int count = 0;while (count++ < 10) {try {sleep(100);System.out.println("synProc: " + count); } catch (InterruptedException e) {e.printStackTrace();}}}synchronized public void synProc2() {int count = 0;while (count++ < 10) {try {sleep(100);System.out.println("synProc2: " + count); } catch (InterruptedException e) {e.printStackTrace();}}}}public class Main{public static void main(String[] args) { MyThread thread = new MyThread(); thread.synProc2();}}// 输出synProc2: 1synProc2: 2synProc2: 3synProc2: 4synProc2: 5synProc2: 6synProc2: 7synProc2: 8synProc2: 9synProc2: 10synProc: 1synProc: 2synProc: 3synProc: 4synProc: 5synProc: 6synProc: 7synProc: 8synProc: 9synProc: 10synchronized可以加到静态方法前面，每个类也有一个锁，调用同步静态方法就是获得类级别的锁，这使类中的所有同步静态方法变得有序，即只有一个同步静态方法被调用，其他的同步静态就只好等待它结束才能被调用。