尚学堂--线程
本章内容：
- 线程的基本概念
- 线程的创建和启动
- 线程的调度和优先级
- 线程的状态控制
- 线程同步
1、线程基本概念：
线程：一个程序里面不同的执行路径（main()方法叫主线程）。
进程：只是一个静态的概念，例如：机器上的一个.class文件，机器上的一个.exe文件这个叫一个进程
多线程： 在同一个时间点上，一个CPU只能支持一个线程在执行
程序执行过程：
把程序的代码放到内存（代码区）里面，放进去之后并没开始执行，这个时候说明一个进程已经产生了，
但还没开始执行，这叫一个进程。进程是一个静态的概念，平时所说的进程的执行说的是进程里面主线程
（main方法）开始执行。进程是一个静态概念，实际上机器里面运行的都是线程。
CPU的执行是这样的：
CPU的速度很快，一秒钟可以算好几亿次，因此CPU把自己的时间分成一个个小时间片，我这个时间片执行你一会，下一个时间片执行他一会，再下一个时间片又执行其他人一会，虽然有几十个线程，但一样可以在很短的时间内把他们通通都执行一遍，但对我们人来说，CPU的执行速度太快了，因此看起来就像是在同时执行一样，但实际上在一个时间点上，CPU只有一个线程在运行。什么才是真正的多线程？如果你的机器是双CPU，或者是双核，这确确实实是多线程。
2、线程的创建和启动
- java的线程是通过java.lang.Thread类来实现的
- VM启动时会有一个由主方法（public static void main() {} ）所定义的线程
- 可以通过创建Thread的实例来创建新的线程
- 每个线程都是通过某个特定的Thread对象所对应的方法run()来完成操作的，方法run()称为线程体
- 通过调用Thread类的start()方法来启动一个线程
创建一个新的线程：
- 实现Runnable接口
- 继承Thread类
实现Runnable接口：（Runnable接口只有一个run方法，重写run方法后，需要调用Thread中的start()方法就必须new一个Thread出来，并把线程类对象作为实参传入）
public class Test {
public static void main(String[] args) {
MyRunner mr = new MyRunner();//new一个线程类的对象
//mr.run(); 方法调用，方法调用的执行是等run()方法执行完之后才会继续执行main()方法
Thread th = new Thread(mr);//要启动一个线程类就必须new一个Thread对象出来，调用Thread(Runnable target)构造方法
th.start();//启动新开辟的线程，新线程执行的是run()方法，新线程与主线程并行执行
for(int i = 0; i < 100; i ++) {
System.out.println("MainThread ------ " + i);
}
}
}
//定义一个类来实现Runnable接口，实现Runnable接口就表示这个类是一个线程类
class MyRunner implements Runnable {
public void run() {
for(int i = 0; i < 100; i ++) {
System.out.println("MyRunner : " + i);
}
}
}
继承Thread类：（Thread的子类要重写run方法，然后调用Thread的start方法启动新线程）
public class Test { public static void main(String[] args) { MyRunner mr = new MyRunner(); mr.start();//调用start()方法启动新开辟的线程 for(int i=0; i<=100; i++) { System.out.println("MainThread ----" + i); } } } /* MyRunner类从Thread类继承，通过实例化MyRunner的一个对象就能开辟一个新的线程， 调用从Thread类继承来的start()方法就可以启动新开辟的线程 */ class MyRunner extends Thread { public void run() { for(int i=0; i<=100; i++) { System.out.println("MyRunner : " + i); } } }
使用实现Runnable接口和继承Thread类这两种开辟新线程的方法的选择应该优先选择实现Runnable接口这种方式去开辟一个新的线程。因为接口的实现可以实现多个，而类的继承只能是单继承。因此在开辟新线程时能够使用Runnable接口就尽量不要使用从Thread类继承的方式来开辟新的线程
3、线程的调度和优先级
isAlive：就绪、运行、阻塞状态表示还“活”着，终止、new出来没有启动也是“死”的
4、线程的状态控制
sleep方法实例：
import java.util.*;//包中存放了Date()方法 public class Test { public static void main(String[] args) { MyRunner mr = new MyRunner(); Thread tr = new Thread(mr); tr.start();//start自动调用run()方法开始新的进程 try { Thread.sleep(10000);//sleep为静态方法,可以通过类直接调用，main进程暂停执行10s } catch(InterruptedException ae) { // no } tr.interrupt(); } } class MyRunner implements Runnable { public void run() { while(true) { System.out.println("====" + new Date() + "===="); try { Thread.sleep(1000);//为什么用Thread.sleep，不能用MyRunner.sleep() } catch(InterruptedException ae) { return; //进程停止，不使用return，会一直输出时间，不停止 } } } }
john方法：
public class Test { public static void main(String[] args) { MyRunner mr = new MyRunner(); Thread tr = new Thread(mr); tr.start(); try { tr.join();//效果相当于方法调用 } catch(InterruptedException ae) { // } for(int i=1; i<=10; i++) { System.out.println("i am main Thread"); } } } class MyRunner implements Runnable { public void run() { for(int i=0; i<=10; i++) { System.out.println("i am" + i); try { Thread.sleep(1000); } catch(InterruptedException ae) { return; } } } }
yield方法：
线程的优先级：
public class Test { public static void main(String[] args) { Thread t1 = new Thread(new T1()); Thread t2 = new Thread(new T2()); t1.setPriority(Thread.NORM_PRIORITY + 3); t1.start(); t2.start(); //因为是多线程，"t1的优先级：" + t1.getPriority() 语句不一定是在最后输出 System.out.println("t1的优先级：" + t1.getPriority()); } } class T1 implements Runnable { public void run() { for(int i=0; i<=10; i++) { System.out.println("-----T1 " + i); } } } class T2 implements Runnable { public void run() { for(int i=0; i<=10; i++) { System.out.println("-----T2 " + i); } } }
5、线程同步
public class Test implements Runnable { Timer test = new Timer(); public static void main(String[] args) { Test t = new Test();//new线程类对象 Thread t1 = new Thread(t); Thread t2 = new Thread(t); t1.setName("t1"); t2.setName("t2"); t1.start(); t2.start(); } public void run() { test.add(Thread.currentThread().getName()); } } class Timer { private static int num = 0; public void add(String name) { num ++; try { Thread.sleep(1);//即使不写sleep，第一个线程执行过程中也很可能被第二个线程打断。Thread.sleep(1)只是为了放大这个效果 } catch(InterruptedException e) { // no } System.out.println(name + ",你是第" + num + "个使用timer的线程"); } }
防止一个线程在执行过程中被另外的线程打断：
- synchronized 声明方法
- 将代码写在synchronized(this){}方法体中
public class Test implements Runnable { Timer test = new Timer(); public static void main(String[] args) { Test t = new Test();//new线程类对象 Thread t1 = new Thread(t); Thread t2 = new Thread(t); t1.setName("t1");//改变线程名称，使之与参数 name 相同 t2.setName("t2"); t1.start();//调用run()方法 t2.start(); } public void run() { test.add(Thread.currentThread().getName()); } } class Timer { private static int num = 0; public synchronized void add(String name) {// 在声明方法时加入synchronized时表示在执行这个方法的过程之中当前对象被锁 //synchronized(this) { 锁定当前对象（一个线程在执行方法体语句过程中不会被另外一个线程打断） num ++; try { Thread.sleep(1);//即使不写sleep，第一个线程执行过程中也很可能被第二个线程打断。Thread.sleep(1)只是为了放大这个效果 } catch(InterruptedException e) { // no } System.out.println(name + ",你是第" + num + "个使用timer的线程"); //} } }
线程死锁：
/*这个小程序模拟的是线程死锁的问题*/ public class TestDeadLock implements Runnable { public int flag = 1; static Object o1 = new Object(), o2 = new Object(); public void run() { System.out.println(Thread.currentThread().getName() + "的flag=" + flag); /* * 运行程序后发现程序执行到这里打印出flag以后就再也不往下执行后面的if语句了 * 程序也就死在了这里，既不往下执行也不退出 */ /* 这是flag=1这个线程 */ if (flag == 1) { synchronized (o1) { /* 使用synchronized关键字把对象01锁定了 */ try { Thread.sleep(500); } catch (InterruptedException e) { e.printStackTrace(); } synchronized (o2) { /* * 前面已经锁住了对象o1，只要再能锁住o2，那么就能执行打印出1的操作了 * 可是这里无法锁定对象o2，因为在另外一个flag=0这个线程里面已经把对象o1给锁住了 * 尽管锁住o2这个对象的线程会每隔500毫秒睡眠一次，可是在睡眠的时候仍然是锁住o2不放的 */ System.out.println("1"); } } } /* * 这里的两个if语句都将无法执行，因为已经造成了线程死锁的问题 * flag=1这个线程在等待flag=0这个线程把对象o2的锁解开， * 而flag=0这个线程也在等待flag=1这个线程把对象o1的锁解开 * 然而这两个线程都不愿意解开锁住的对象，所以就造成了线程死锁的问题 */ /* 这是flag=0这个线程 */ if (flag == 0) { synchronized (o2) { /* 这里先使用synchronized锁住对象o2 */ try { Thread.sleep(500); } catch (InterruptedException e) { e.printStackTrace(); } synchronized (o1) { /* * 前面已经锁住了对象o2，只要再能锁住o1，那么就能执行打印出0的操作了 可是这里无法锁定对象o1，因为在另外一个flag=1这个线程里面已经把对象o1给锁住了 尽管锁住o1这个对象的线程会每隔500毫秒睡眠一次，可是在睡眠的时候仍然是锁住o1不放的 */ System.out.println("0"); } } } } 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); Thread t2 = new Thread(td2); t1.setName("线程td1"); t2.setName("线程td2"); t1.start(); t2.start(); } }
