1.什么是线程
线程是一个程序内部的顺序控制流。
线程和进程：
每个进程都有独立的代码和数据空间（进程上下文），进程切换的开销大。
线程: 轻量的进程，同一类线程共享代码和数据空间，每个线程有独立的运行栈和程序计数器（PC），线程切换的开销小。
多进程： 在操作系统中能同时运行多个任务（程序）
多线程：在同一应用程序中有多个顺序流同时执行
2.线程的概念模型
1. 虚拟的CPU，由java.lang.Thread类封装和虚拟；
2. CPU所执行的代码，传递给Thread类对象；
3. CPU所处理的数据，传递给Thread类对象。
Java的线程是通过java.lang.Thread类来实现的。
每个线程都是通过某个特定Thread对象所对应的，方法run( )来完成其操作的，方法run( )称为线程体。
3.创建线程的两种方式的比较
一. 使用Runnable接口创建线程：
可以将CPU(Tread 类)、代码和数据(Runnable接口 run 方法)分开，形成清晰的模型；线程体run()方法所在的类还可以从其他类继承一些有用的属性或方法；
并有利于保持程序风格的一致性。
public class TestTread1{ public static void main(String args[]) { Runner1 r = new Runner1(); Thread t = new Thread(r); t.start(); } } class Runner1 implements Runnable { public void run() { for(int i=0; i<30; i++) { System.out.println("No. " + i); } } }
二. 直接继承Thread类创建线程：
Thread子类无法再从其他类继承，编写简单，run()方法的当前对象就是线程对象，可直接操纵。
public class TestTread2{ public static void main(String args[]){ Thread t = new Runner3(); t.start(); } } class Runner3 extends Thread { public void run() { for(int i=0; i<30; i++) { System.out.println("No. " + i); } } }
4.多线程
Java 中 引 入 线 程 机 制 的 目 的 在 于 实 现 多 线 程 （Multi-Thread）,多线程之间可以共享代码和数据。
public class TestTread3{ public static void main(String args[]) { Runner2 r = new Runner2(); Thread t1 = new Thread(r); Thread t2 = new Thread(r); t1.start(); t2.start(); } } class Runner2 implements Runnable { public void run() { for(int i=0; i<10; i++) { String s = Thread.currentThread().getName(); System.out.println(s + ": " + i); } } }
结果:
Thread-0: 0 Thread-0: 1 Thread-0: 2 Thread-0: 3 Thread-0: 4 Thread-0: 5 Thread-0: 6 Thread-0: 7 Thread-0: 8 Thread-0: 9 Thread-1: 0 Thread-1: 1 Thread-1: 2 Thread-1: 3 Thread-1: 4 Thread-1: 5 Thread-1: 6 Thread-1: 7 Thread-1: 8 Thread-1: 9
5.后台线程
相关基本概念：
后台处理（Background Processing）:让某些程序的运行让步给其他的优先级高的程序
后台线程（Background Thread / Daemon Thread）:以后台的方式(往往是服务线程)运行的线程,例如定时器线程
用户线程（User Thread）:完成用户指定的任务的线程
主线程（Main Thread）:它就是一种主线程
子线程（Sub Thread）:在线程中创建的线程就是子线程
Thread类提供的相关方法：
public final boolean isDaemon():判断某个线程是不是一个后台线程
public final void setDaemon(Boolean on):设置某个线程为一个后台线程
举例：
package v512.chap16; public class TestDaemonThread { public static void main(String args[]){ Thread t1 = new MyRunner(10); t1.setName("用户线程t1"); t1.start(); Thread t2 = new MyRunner(50); t2.setDaemon(true); t2.setName("后台线程t2"); t2.start(); for(int i=0;i<10;i++){ System.out.println(Thread.currentThread().getName() + ": " + i); } System.out.println("主线程结束!"); } } class MyRunner extends Thread { private int n; public MyRunner(int n){ this.n = n; } public void run() { for(int i=0; i<n; i++) { System.out.println(this.getName() + ": " + i); } System.out.println(this.getName() + "结束!"); } }
结果:
用户线程t1: 0 用户线程t1: 1 用户线程t1: 2 用户线程t1: 3 用户线程t1: 4 用户线程t1: 5 用户线程t1: 6 用户线程t1: 7 用户线程t1: 8 用户线程t1: 9 用户线程t1结束! main: 0 main: 1 main: 2 main: 3 main: 4 main: 5 main: 6 main: 7 main: 8 main: 9 主线程结束! 后台线程t2: 0 后台线程t2: 1 后台线程t2: 2 后台线程t2: 3 后台线程t2: 4 后台线程t2: 5 后台线程t2: 6 后台线程t2: 7 后台线程t2: 8 后台线程t2: 9 后台线程t2: 10 后台线程t2: 11 后台线程t2: 12 后台线程t2: 13 后台线程t2: 14 后台线程t2: 15 后台线程t2: 16 后台线程t2: 17 后台线程t2: 18 后台线程t2: 19 后台线程t2: 20 后台线程t2: 21 后台线程t2: 22 后台线程t2: 23 后台线程t2: 24 后台线程t2: 25 后台线程t2: 26 后台线程t2: 27 后台线程t2: 28 后台线程t2: 29 后台线程t2: 30 后台线程t2: 31 后台线程t2: 32 后台线程t2: 33 后台线程t2: 34 后台线程t2: 35 后台线程t2: 36 后台线程t2: 37 后台线程t2: 38 后台线程t2: 39 后台线程t2: 40 后台线程t2: 41 后台线程t2: 42 后台线程t2: 43 后台线程t2: 44 后台线程t2: 45 后台线程t2: 46 后台线程t2: 47 后台线程t2: 48 后台线程t2: 49 后台线程t2结束!
6.GUI线程
GUI程序运行过程中系统会自动创建若干GUI线程
常见GUI线程：
AWT-Windows线程:(windows 系统中)后台线程
AWT-EventQueue-n线程
AWT-Shutdown线程：负责关闭窗体中的抽象窗口工具
DestroyJavaVM线程：不是GUI线程，它是当main线程结束之后系统自动创建的，用于等到所有的线程都死掉了之后销毁jvm
实例：
package v512.chap16; import java.awt.*; import java.awt.event.*; public class TestGUIThread { public static void main(String args[]) throws Exception{ Frame f = new Frame(); Button b = new Button("Press Me!"); MyMonitor mm = new MyMonitor(); b.addActionListener(mm); f.addWindowListener(mm); f.add(b,"Center"); f.setSize(100,60); f.setVisible(true); MyThreadViewer.view(); } } class MyMonitor extends WindowAdapter implements ActionListener{ public void actionPerformed(ActionEvent e){ MyThreadViewer.view(); } } class MyThreadViewer{ public static void view(){ Thread current = Thread.currentThread(); System.out.println("当前线程名称: " + current.getName()); int total = Thread.activeCount(); System.out.println("活动线程总数: " + total + "个"); Thread[] threads = new Thread[total]; current.enumerate(threads); for(Thread t : threads){ String role = t.isDaemon()?"后台线程 ":"用户线程 "; System.out.println(" -" + role + t.getName()); } System.out.println("----------------------------------"); } }
运行之后，在点击一下 button
输出结果：
当前线程名称: main 活动线程总数: 4个 -用户线程 main -用户线程 AWT-Shutdown -后台线程 AWT-Windows -用户线程 AWT-EventQueue-0 ---------------------------------- 当前线程名称: AWT-EventQueue-0 活动线程总数: 4个 -用户线程 AWT-Shutdown -后台线程 AWT-Windows -用户线程 AWT-EventQueue-0 -用户线程 DestroyJavaVM ----------------------------------
7.线程的生命周期
新建状态
就绪状态：此时不一定马上就开始运行
运行状态：运行状态的线程可能会发生问题（赚到了阻塞状态）
阻塞状态
终止状态
8.线程的优先级
线程的优先级用数字来表示，范围从1到10。主线程的缺省优先级是5，子线程的优先级默认与其父线程相同。
注意：程序中不能依赖线程的优先级来让线程按照我们的要求来执行！
Thread类提供的相关方法：
public final int getPriority();
public final void setPriority(int newPriority)；
相关静态整型常量：
Thread.MIN_PRIORITY = 1
Thread.MAX_PRIORITY = 10
Thread.NORM_PRIORITY = 5
用法举例：
package v512.chap16; public class TestPriority { public static void main(String args[]){ System.out.println("线程名\t优先级"); Thread current = Thread.currentThread(); System.out.print(current.getName() + "\t"); System.out.println(current.getPriority()); Thread t1 = new Runner(); Thread t2 = new Runner(); Thread t3 = new Runner(); t1.setName("First"); t2.setName("Second"); t3.setName("Third"); t2.setPriority(Thread.MAX_PRIORITY); t3.setPriority(8); t1.start(); t2.start(); t3.start(); } } class Runner extends Thread { public void run() { System.out.print(this.getName() + "\t"); System.out.println(this.getPriority()); } }
输出结果：
线程名 优先级 main 5 First 5 Second 10 Third 8
9.线程的串行化
在多线程程序中，如果在一个线程运行的过程中要用到另一个线程的运行结果，则可进行线程的串型化处理。
Thread类提供的相关方法：
public final void join()
public final void join(long millis) //等待毫秒数
public final void join(long millis,int nanos)
测试 主线程必须要等到子线程运行完成之后才可以运行：
package v512.chap16; public class TestJoin { public static void main(String args[]){ MyRunner2 r = new MyRunner2(); Thread t = new Thread(r); t.start(); try{ t.join(); }catch(InterruptedException e){ e.printStackTrace(); } for(int i=0;i<20;i++){ System.out.println("主线程:" + i); } } } class MyRunner2 implements Runnable { public void run() { for(int i=0;i<20;i++) { System.out.println("SubThread: " + i); } } }
输出结果：
SubThread: 0 SubThread: 1 SubThread: 2 SubThread: 3 SubThread: 4 SubThread: 5 SubThread: 6 SubThread: 7 SubThread: 8 SubThread: 9 SubThread: 10 SubThread: 11 SubThread: 12 SubThread: 13 SubThread: 14 SubThread: 15 SubThread: 16 SubThread: 17 SubThread: 18 SubThread: 19 主线程:0 主线程:1 主线程:2 主线程:3 主线程:4 主线程:5 主线程:6 主线程:7 主线程:8 主线程:9 主线程:10 主线程:11 主线程:12 主线程:13 主线程:14 主线程:15 主线程:16 主线程:17 主线程:18 主线程:19
10.线程休眠
线程休眠——暂停执行当前运行中的线程，使之进入阻塞状态，待经过指定的“延迟时间”后再醒来并转入到就绪状态。
Thread类提供的相关方法：
public static void sleep(long millis)
public static void sleep(long millis, int nanos)
用法举例： 数字时钟
package v512.chap16; import java.util.*; import javax.swing.*; public class DigitalClock{ public static void main(String[] args){ JFrame jf = new JFrame("Clock"); JLabel clock = new JLabel("Clock"); clock.setHorizontalAlignment(JLabel.CENTER); jf.add(clock,"Center"); jf.setSize(140,80); jf.setLocation(500,300); jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); jf.setVisible(true); while(true){ clock.setText(getTime()); try{ Thread.sleep(1000); //this.sleep(1000); }catch(InterruptedException e){ e.printStackTrace(); } } } public static String getTime(){ Calendar c = new GregorianCalendar(); String time = c.get(Calendar.YEAR) + "-" + (c.get(Calendar.MONTH) + 1) + "-" + c.get(Calendar.DATE) + " " ; int h = c.get(Calendar.HOUR_OF_DAY); int m = c.get(Calendar.MINUTE); int s = c.get(Calendar.SECOND); String ph = h<10 ? "0":""; String pm = m<10 ? "0":""; String ps = s<10 ? "0":""; time += ph + h + ":" + pm + m + ":" + ps + s; return time; } }
显示效果：
11.线程让步
线程让步——让运行中的线程主动放弃当前获得的 CPU 处理机会，但不是使该线程阻塞，而是使之转入就绪状态。
Thread类提供的相关方法：
public static void yield()
用法举例：
package v512.chap16; import java.util.Date; public class TestYield{ public static void main(String[] args){ Thread t1 = new MyThread(false); Thread t2 = new MyThread(true); Thread t3 = new MyThread(false); t1.start(); t2.start(); t3.start(); } } class MyThread extends Thread{ private boolean flag; public MyThread(boolean flag){ this.flag = flag; } public void setFlag(boolean flag){ this.flag = flag; } public void run(){ long start = new Date().getTime(); for(int i=0;i<500;i++){ if(flag) Thread.yield(); System.out.print(this.getName() + ": " + i + "\t"); } long end = new Date().getTime(); System.out.println("\n" + this.getName() + "执行时间: " + (end - start) + "毫秒"); } }
输出结果太多了，不便贴出，可以查看一下执行时间
Thread-0执行时间: 67毫秒
Thread-2执行时间: 84毫秒
Thread-1执行时间: 148毫秒
12.线程的挂起和恢复
线程挂起——暂时停止当前运行中的线程，使之转入阻塞状态，并且不会自动恢复运行。
线程恢复——使得一个已挂起的线程恢复运行。
Thread类提供的相关方法：
public final void suspend()
public final void resume()
用法举例：
package v512.chap16; import java.awt.Color; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import java.util.Date; import javax.swing.JFrame; import javax.swing.JLabel; import javax.swing.JButton; public class TestSuspend{ public static void main(String[] args){ JFrame jf = new JFrame("Timer"); JButton pause = new JButton("Pause"); JLabel clock = new JLabel("Timer"); clock.setBackground(Color.GREEN); clock.setOpaque(true); clock.setHorizontalAlignment(JLabel.CENTER); jf.add(clock,"Center"); jf.add(pause,"North"); jf.setSize(140,80); jf.setLocation(500,300); jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); jf.setVisible(true); MyThread3 mt = new MyThread3(clock,10000); mt.start(); MyListener ml = new MyListener(clock,mt); pause.addActionListener(ml); } } class MyThread3 extends Thread{ private JLabel clock; private long time; private long end; public MyThread3(JLabel clock,long time){ this.clock = clock; this.time = time; } public void init(){ long start = new Date().getTime(); end = start + time; } public void run(){ this.init(); while(true){ long now = new Date().getTime(); time = end - now; if(time > 0){ String s = this.convert(time); clock.setText(s); }else{ break; } try{ Thread.sleep(10); }catch(InterruptedException e){ e.printStackTrace(); } } clock.setText("时间到!"); clock.setBackground(Color.RED); } public String convert(long time){ long h = time / 3600000; long m = (time % 3600000) / 60000; long s = (time % 60000) / 1000; long ms = (time % 1000) / 10; String ph = h<10 ? "0":""; String pm = m<10 ? "0":""; String ps = s<10 ? "0":""; String pms = ms<10 ? "0":""; String txt = ph + h + ":" + pm + m + ":" + ps + s + "." + pms + ms; return txt; } } class MyListener implements ActionListener{ private JLabel clock; private MyThread3 mt; private boolean running= true; public MyListener(JLabel clock,MyThread3 mt){ this.clock = clock; this.mt = mt; } public void actionPerformed(ActionEvent e){ if(!mt.isAlive()) return; JButton jb = (JButton)(e.getSource()); if(running){ jb.setText("Replay"); clock.setBackground(Color.YELLOW); mt.suspend(); }else{ jb.setText("Pause"); clock.setBackground(Color.green); mt.init(); mt.resume(); } running = !running; } }
测试结果：
13.终止线程
一种特别优雅的方式终止线程（设置标志 flag）
实例：
public class Test { public static void main(String args[]){ Runner r = new Runner(); Thread t = new Thread(r); t.start(); for(int i=0;i<10;i++){ try{ Thread.sleep(5); System.out.println("\nin thread main i=" + i); }catch(InterruptedException e){ e.printStackTrace(); } } System.out.println("Thread main is over"); r.shutDown(); } }
public class Runner implements Runnable { private boolean flag=true; public void run() { int i = 0; while (flag == true) { System.out.print(" " + i++); } } public void shutDown() { flag = false; } }
main线程结束之后，子线程也就结束了（flag == false）
14.线程控制的基本方法
15. 临界资源问题
临界资源问题实例：
两个线程A和B在同时操纵Stack类的同一个实例（栈），A向栈里push一个数据，B则要从堆栈中pop一个数据。
栈的模拟 public class Stack{ int idx=0; char[ ] data = new char[6]; public void push(char c){ data[idx] = c; idx++; } public char pop(){ idx--; return data[idx]; } }
可能出现的问题
（4 中 c 应该是不存在的）
16. 互斥锁 和 死锁
在Java语言中，引入了对象互斥锁的概念，来保证共享数据操作的完整性。
每个对象都对应于一个可称为“互斥锁”的标记，这个标记用来保证在任一时刻，只能有一个线程访问该对象。
关键字synchronized 来与对象的互斥锁联系。当某个对象用synchronized修饰时，表明该对象在任一时刻只能由一个线程访问。
synchronized用法
①用于方法声明中，标明整个方法为同步方法：这个时候调用这个方法的对象是处于被当前的线程锁定的状态
public synchronized void push(char c){ data[idx] = c; idx++; }
②用于修饰语句快，标明整个语句块为同步块：这个时候 synchronized 中的对象是被当前的线程锁定了的
public char pop(){ //其它代码 synchronized(this){ idx--; return data[idx]; } //其它代码 }
并发运行的多个线程间彼此等待、都无法运行的状态称为线程死锁。
线程死锁实例一：
package v512.chap16; public class TestDeadLock{ public static void main(String args[]){ StringBuffer sb = new StringBuffer("ABCD"); MyThread4 t = new MyThread4(sb); t.start(); synchronized(sb){ try{ t.join(); }catch(InterruptedException e){ e.printStackTrace(); } System.out.println(sb); } System.out.println("Main thread is over!"); } } class MyThread4 extends Thread{ private StringBuffer sb; public MyThread4(StringBuffer sb){ this.sb = sb; } public void run(){ synchronized(sb){ sb.reverse(); } System.out.println("Sub thread is over!"); } }
控制台什么都没有输出来！
分析：在main方法的同步块中串行插入了子线程t，并锁定了sb对象，然而子线程的run方法中也有一个同步块，它要锁定的对象正是sb对象，
然而sb对象已经被主线程给锁定了，子线程只能等待，另一方面，主线程又必须要等到子线程结束了之后才可以执行，两者就这么一直等待着，
陷入了死锁的状态！
如果删除掉main中的同步，就可以看到结果：
Sub thread is over! DCBA Main thread is over!
实例二：
package v512.chap16; public class TestDeadLock2{ public static void main(String args[]){ char[] a = {'A','B','C'}; char[] b = {'D','E','F'}; MyThread5 t1 = new MyThread5(a,b); MyThread5 t2 = new MyThread5(b,a); t1.start(); t2.start(); } } class MyThread5 extends Thread{ private char[] source; private char[] dest; public MyThread5(char[] source,char[] dest){ this.source = source; this.dest = dest; } public void run(){ synchronized(source){ try{ Thread.sleep(1000); }catch(InterruptedException e){ e.printStackTrace(); } synchronized(dest){ System.arraycopy(source,0,dest,0,source.length); System.out.println(dest); } } } }
假设线程t1先执行run，然后将字符数组a锁定了，接着t1休眠了，线程t2开始执行，并将数组b锁定了，之后线程t2进入休眠，
然后线程t1重新执行，这时候发现数组b已经被线程t2给锁定了，只能等待，休眠之后，线程t2同样发现数组a被线程t1给锁定了，
两者相互之间等待着，就陷入了死锁状态！
17.线程的同步通信
为避免死锁，在线程进入阻塞状态时应尽量释放其锁定的资源，以为其他的线程提供运行的机会。
相关方法：
public final void wait() :会导致当前的线程进入阻塞状态并尽量释放其锁定的资源
public final void notify()：将某个线程重新恢复过来，但不是马上就进入到就绪状态，它可能还要等，等到它要使用的对象解除了锁定才行
public final void notifyAll()
生产者 和 消费者 问题：
同步的栈：
package v512.chap16; public class SyncStack { // 支持多线程同步操作的堆栈的实现 private int index = 0; private char[] data = new char[6]; public synchronized void push(char c) { while (index == data.length) { try { this.wait(); } catch (InterruptedException e) { } } this.notify(); data[index] = c; index++; System.out.println("produced：" + c); } public synchronized char pop() { while (index == 0) { try { this.wait(); } catch (InterruptedException e) { } } this.notify(); index--; System.out.println("consumed：" + data[index]); return data[index]; } }
测试类：包括了生产者和消费者
package v512.chap16; public class SyncTest{ public static void main(String args[]){ SyncStack stack = new SyncStack(); Runnable p=new Producer(stack); Runnable c = new Consumer(stack); Thread t1 = new Thread(p); Thread t2 = new Thread(c); t1.start(); t2.start(); } } class Producer implements Runnable{ SyncStack stack; public Producer(SyncStack s){ stack = s; } public void run(){ for(int i=0; i<20; i++){ char c =(char)(Math.random()*26+'A'); stack.push(c); try{ Thread.sleep((int)(Math.random()*300)); }catch(InterruptedException e){ } } } } class Consumer implements Runnable{ SyncStack stack; public Consumer(SyncStack s){ stack = s; } public void run(){ for(int i=0;i<20;i++){ char c = stack.pop(); try{ Thread.sleep((int)(Math.random()*500)); }catch(InterruptedException e){ } } } }
输出结果：
produced：M consumed：M produced：N consumed：N produced：P produced：A consumed：A consumed：P produced：Z consumed：Z produced：F produced：J produced：X produced：Q consumed：Q produced：N produced：W produced：K consumed：K produced：I consumed：I produced：A consumed：A produced：Z consumed：Z produced：M consumed：M produced：X consumed：X produced：X consumed：X produced：P consumed：P produced：V consumed：V consumed：W consumed：N consumed：X consumed：J consumed：F
18.多线程编程专题 (还未仔细看)
线程间数据传输
例16-16 使用管道流实现线程间数据传输
类的同步性与线程安全
例16-17 验证同步类的线程安全性
定时器
例16-18 使用定时器实现数字时钟功能