1、多线程概述
1）进程：
正在运行的程序，是系统进行资源分配和调用的独立单位。
每一个进程都有它自己的内存空间和系统资源。
2）线程：
在同一个进程内又可以执行多个任务，而这每一个任务我就可以看出是一个线程。
线程：是程序的执行单元，执行路径。是程序使用CPU的最基本单位。
单线程：程序只有一条执行路径。
多线程：程序有多条执行路径。
3）多线程有什么意义?
多线程的存在，不是提高程序的执行速度。其实是为了提高应用程序的使用率。
程序的执行其实都是在抢CPU的资源，CPU的执行权。多个进程是在抢这个资源，而其中的某一个进程如果执行路径比较多，就会有更高的几率抢到CPU的执行权。我们是不敢保证哪一个线程能够在哪个时刻抢到，所以线程的执行有随机性。
4）并行和并发
并发是逻辑上同时发生，指在某一个时间内同时运行多个程序。
并行是物理上同时发生，指在某一个时间点同时运行多个程序。
5）Java程序运行原理
java 命令会启动 java 虚拟机，启动 JVM，等于启动了一个应用程序，也就是启动了一个进程。该进程会自动启动一个 “主线程” ，然后主线程去调用某个类的 main 方法。所以 main方法运行在主线程中。在此之前的所有程序都是单线程的。
jvm虚拟机的启动是多线程的。因为垃圾回收线程也要先启动，否则很容易会出现内存溢出。现在的垃圾回收线程加上前面的主线程，最少启动了两个线程，所以，jvm的启动是多线程的。
2、多线程实现方案
1） Java可以去调用C/C++写好的程序来实现多线程程序。由C/C++去调用系统功能创建进程，然后由Java去调用这样的东西，然后提供一些类供我们使用。我们就可以实现多线程程序了。
2）实现方式1：继承Thread类。将类声明为 Thread 的子类。该子类应重写 Thread 类的 run 方法。接下来可以分配并启动该子类的实例。
A：自定义类MyThread继承Thread类。
B：MyThread类里面重写run()
C：创建对象
D：启动线程
例子1：
自定义线程类：
package threaddemos; /* * 该类要重写run()方法,为什么呢? * 不是类中的所有代码都需要被线程执行的。 * 而这个时候，为了区分哪些代码能够被线程执行，java提供了Thread类中的run()用来包含那些被线程执行的代码。 */ public class MyThread extends Thread{ @Override public void run(){ for (int x = 0; x < 200; x++) { System.out.println(x); } } }
测试类：
package threaddemos; /** * Created by gao on 16-1-3. */ public class ThreadDemo01 { public static void main(String[] args) { // 创建线程对象 // MyThread my = new MyThread(); // // 启动线程 // my.run(); // my.run(); // 调用run()方法为什么是单线程的呢? // 因为run()方法直接调用其实就相当于普通的方法调用,所以你看到的是单线程的效果 // 面试题：run()和start()的区别? // run():仅仅是封装被线程执行的代码，直接调用是普通方法 // start():首先启动了线程，然后再由jvm去调用该线程的run()方法。 // MyThread my = new MyThread(); // my.start(); // // IllegalThreadStateException:非法的线程状态异常 // // 为什么呢?因为这个相当于是my线程被调用了两次。而不是两个线程启动。 // my.start(); // 创建两个线程对象 MyThread my1 = new MyThread(); MyThread my2 = new MyThread(); my1.start(); my2.start(); } }
3）Thread类的基本获取和设置方法
public final String getName()：返回该线程的名称。
public final void setName(String name)：改变线程名称，使之与参数 name 相同。
其实通过构造方法也可以给线程起名字
4）获取main方法所在的线程名称
public static Thread currentThread()：返回对当前正在执行的线程对象的引用。
例子2：
自定义线程：
package threaddemos; public class MyThread2 extends Thread { public MyThread2() { } public MyThread2(String name) { super(name); } @Override public void run() { for (int x = 0; x < 200; x++) { System.out.println(getName() + "---" + x); } } }
测试类：
package threaddemos; /** * Created by gao on 16-1-3. */ public class ThreadDemo02 { public static void main(String[] args) { // 创建线程对象 //无参构造+setXxx() // MyThread2 my1 = new MyThread2(); // MyThread2 my2 = new MyThread2(); // my1.setName("林青霞"); // my2.setName("刘意"); // my1.start(); // my2.start(); //带参构造方法给线程起名字 MyThread2 my1 = new MyThread2("林青霞"); MyThread2 my2 = new MyThread2("刘意"); my1.start(); my2.start(); //获取main方法所在的线程对象的名称 //public static Thread currentThread():返回当前正在执行的线程对象 System.out.println(Thread.currentThread().getName()); } } /* 名称为什么是：Thread-? 编号 class Thread { private char name[]; public Thread() { init(null, null, "Thread-" + nextThreadNum(), 0); } private void init(ThreadGroup g, Runnable target, String name, long stackSize) { init(g, target, name, stackSize, null); } private void init(ThreadGroup g, Runnable target, String name, long stackSize, AccessControlContext acc) { //大部分代码被省略了 this.name = name.toCharArray(); } public final void setName(String name) { this.name = name.toCharArray(); } private static int threadInitNumber; //0,1,2 private static synchronized int nextThreadNum() { return threadInitNumber++; //return 0,1 } public final String getName() { return String.valueOf(name); } } class MyThread extends Thread { public MyThread() { super(); } } */
5）实现方式2：声明实现 Runnable 接口的类。该类然后实现 run 方法。然后可以分配该类的实例，在创建 Thread 时作为一个参数来传递并启动。
A:自定义类MyRunnable实现Runnable接口
B:重写run()方法
C:创建MyRunnable类的对象
D:创建Thread类的对象，并把C步骤的对象作为构造参数传递
自定义类：
package threaddemos; /** * Created by gao on 16-1-4. */ public class MyRunnable implements Runnable { @Override public void run() { for (int x = 0; x < 100; x++) { // 由于实现接口的方式就不能直接使用Thread类的方法了,但是可以间接的使用 System.out.println(Thread.currentThread().getName() + "---" + x); } } }
测试类：
package threaddemos; /** * Created by gao on 16-1-4. */ public class MyRunnableDemo { public static void main(String[] args) { // 创建MyRunnable类的对象 MyRunnable my = new MyRunnable(); // 创建Thread类的对象，并把C步骤的对象作为构造参数传递 // Thread(Runnable target) // Thread t1 = new Thread(my); // Thread t2 = new Thread(my); // t1.setName("林青霞"); // t2.setName("刘意"); // Thread(Runnable target, String name) Thread t1 = new Thread(my,"林青霞"); Thread t2 = new Thread(my,"刘意"); t1.start(); t2.start(); } }
6）多线程两种方式的图解比较和区别：
3、线程调度和线程控制
1）线程调度
假如我们的计算机只有一个 CPU，那么 CPU 在某一个时刻只能执行一条指令，线程只有得到 CPU时间片，也就是使用权，才可以执行指令。那么Java是
如何对线程进行调用的呢？
线程有两种调度模型：
· 分时调度模型：所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间片.
· 抢占式调度模型：优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个，优先级高的线程获取的 CPU 时间片相对多一些。
· Java使用的是抢占式调度模型。
2）设置和获取线程优先级
· public final int getPriority()：返回线程的优先级。
· public final void setPriority(int newPriority)：更改线程的优先级。
package threaddemos; /** * Created by gao on 16-1-4. */ /* * 我们的线程没有设置优先级,肯定有默认优先级。 * 获取线程对象的优先级 * public final int getPriority():返回线程对象的优先级 * 设置线程对象的优先级 * public final void setPriority(int newPriority)：更改线程的优先级。 * * 注意： * 线程默认优先级是5。 * 线程优先级的范围是：1-10。 * 线程优先级高仅仅表示线程获取的 CPU时间片的几率高，但是要在次数比较多，或者多次运行的时候才能看到比较好的效果。 * * IllegalArgumentException:非法参数异常。 * 抛出的异常表明向方法传递了一个不合法或不正确的参数。 */ public class ThreadPriorityDemo01 { public static void main(String[] args) { ThreadPriority tp1 = new ThreadPriority(); ThreadPriority tp2 = new ThreadPriority(); ThreadPriority tp3 = new ThreadPriority(); tp1.setName("东方不败"); tp2.setName("岳不群"); tp3.setName("林平之"); // 获取默认优先级 // System.out.println(tp1.getPriority()); //5 // System.out.println(tp2.getPriority());//5 // System.out.println(tp3.getPriority());//5 // 设置线程优先级(范围出错) // tp1.setPriority(100000); //设置正确的线程优先级 tp1.setPriority(10); tp3.setPriority(1); tp1.start(); tp2.start(); tp3.start(); } }
3）线程控制
· 线程休眠
public static void sleep(long millis)：在指定的毫秒数内让当前正在执行的线程休眠（暂停执行），此操作受到系统计时器和调度程序精度和准确性的影响。
· 线程加入
public final void join()：等待该线程终止。
· 线程礼让
public static void yield()：暂停当前正在执行的线程对象，并执行其他线程。
· 后台线程
public final void setDaemon(boolean on)：将该线程标记为守护线程或用户线程。当正在运行的线程都是守护线程时，Java 虚拟机退出。 该方法必须在启动线程前调用。
· 中断线程
public final void stop()：已过时。不建议使用
public void interrupt()：中断线程
例子1：
自定义Thread类：
package threaddemos; import java.util.Date; /** * Created by gao on 16-1-4. */ public class ThreadSleep extends Thread { public ThreadSleep() { } @Override public void run() { for (int x = 0; x < 100; x++) { System.out.println(getName() + "---" + x + "日期：" + new Date()); //睡眠,1秒钟 try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } } }
测试类：
package threaddemos; /** * Created by gao on 16-1-4. */ /* * 线程休眠 * public static void sleep(long millis) */ public class ThreadSleepDemo { public static void main(String[] args) { ThreadSleep ts1 = new ThreadSleep(); ThreadSleep ts2 = new ThreadSleep(); ThreadSleep ts3 = new ThreadSleep(); ts1.setName("林青霞"); ts2.setName("林志玲"); ts3.setName("林志颖"); ts1.start(); ts2.start(); ts3.start(); ts3.start(); } }
例子2：
ThreadJoin类：
package cn.itcast_04; public class ThreadJoin extends Thread { @Override public void run() { for (int x = 0; x < 100; x++) { System.out.println(getName() + ":" + x); } } }
测试类：
package cn.itcast_04; /* * public final void join():等待该线程终止。 */ public class ThreadJoinDemo { public static void main(String[] args) { ThreadJoin tj1 = new ThreadJoin(); ThreadJoin tj2 = new ThreadJoin(); ThreadJoin tj3 = new ThreadJoin(); tj1.setName("李渊"); tj2.setName("李世民"); tj3.setName("李元霸"); tj1.start(); try { tj1.join(); } catch (InterruptedException e) { e.printStackTrace(); } tj2.start(); tj3.start(); } }
例子3：
ThreadYield类：
package cn.itcast_04; public class ThreadYield extends Thread { @Override public void run() { for (int x = 0; x < 100; x++) { System.out.println(getName() + ":" + x); Thread.yield(); } } }
测试类：
package cn.itcast_04; /* * public static void yield():暂停当前正在执行的线程对象，并执行其他线程。 * 让多个线程的执行更和谐，但是不能靠它保证一人一次。 */ public class ThreadYieldDemo { public static void main(String[] args) { ThreadYield ty1 = new ThreadYield(); ThreadYield ty2 = new ThreadYield(); ty1.setName("林青霞"); ty2.setName("刘意"); ty1.start(); ty2.start(); } }
例子4：
package cn.itcast_04; /* * public final void setDaemon(boolean on):将该线程标记为守护线程或用户线程。 * 当正在运行的线程都是守护线程时，Java 虚拟机退出。 该方法必须在启动线程前调用。 * * 游戏：坦克大战。 */ public class ThreadDaemonDemo { public static void main(String[] args) { ThreadDaemon td1 = new ThreadDaemon(); ThreadDaemon td2 = new ThreadDaemon(); td1.setName("关羽"); td2.setName("张飞"); // 设置收获线程 td1.setDaemon(true); td2.setDaemon(true); td1.start(); td2.start(); Thread.currentThread().setName("刘备"); for (int x = 0; x < 5; x++) { System.out.println(Thread.currentThread().getName() + ":" + x); } } }
例子5：
ThreadStop类：
package cn.itcast_04; import java.util.Date; public class ThreadStop extends Thread { @Override public void run() { System.out.println("开始执行：" + new Date()); // 我要休息10秒钟，亲，不要打扰我哦 try { Thread.sleep(10000); } catch (InterruptedException e) { // e.printStackTrace(); System.out.println("线程被终止了"); } System.out.println("结束执行：" + new Date()); } }
测试类：
package cn.itcast_04; /* * public final void stop():让线程停止，过时了，但是还可以使用。 * public void interrupt():中断线程。 把线程的状态终止，并抛出一个InterruptedException。 */ public class ThreadStopDemo { public static void main(String[] args) { ThreadStop ts = new ThreadStop(); ts.start(); // 你超过三秒不醒过来，我就干死你 try { Thread.sleep(3000); // ts.stop(); ts.interrupt(); } catch (InterruptedException e) { e.printStackTrace(); } } }
4、线程生命周期
5、卖电影票案例
1）方式一：继承Thread类
自定义类：
package threaddemos; /** * Created by gao on 16-1-4. */ public class SellTicket extends Thread { // 定义100张票 // private int tickets = 100; // 为了让多个线程对象共享这100张票，我们其实应该用静态修饰 private static int tickets = 100; @Override public void run() { // 定义100张票 // 每个线程进来都会走这里，这样的话，每个线程对象相当于买的是自己的那100张票，这不合理，所以应该定义到外面 // int tickets = 100; // 是为了模拟一直有票 while (true) { if (tickets > 0) { System.out.println(getName() + "---" + "正在出售第" + (tickets--) + "张票"); } } } }
测试类：
package threaddemos; /** * Created by gao on 16-1-4. */ /* * 某电影院目前正在上映贺岁大片(红高粱,少林寺传奇藏经阁)，共有100张票，而它有3个售票窗口售票，请设计一个程序模拟该电影院售票。 * 继承Thread类来实现。 */ public class SellTicketDemo { public static void main(String[] args) { // 创建三个线程对象 SellTicket st1 = new SellTicket(); SellTicket st2 = new SellTicket(); SellTicket st3 = new SellTicket(); // 给线程对象起名字 st1.setName("窗口1"); st2.setName("窗口2"); st3.setName("窗口3"); // 启动线程 st1.start(); st2.start(); st3.start(); } }
2）方式二：实现Runnable接口
自定义类：
package threaddemos; /** * Created by gao on 16-1-4. */ public class SellTicket2 implements Runnable { private int tickets = 200; @Override public void run() { while (true) { if (tickets > 0) { System.out.println(Thread.currentThread().getName() + "---" + "正在出售第" + (tickets--) + "张票"); } } } }
测试类：
package threaddemos; /** * Created by gao on 16-1-4. */ /* * 实现Runnable接口的方式实现 */ public class SellTicketDemo2 { public static void main(String[] args) { // 创建资源对象 SellTicket2 st = new SellTicket2(); // 创建三个线程对象 Thread t1 = new Thread(st,"窗口1"); Thread t2 = new Thread(st,"窗口2"); Thread t3 = new Thread(st,"窗口3"); // 启动线程 t1.start(); t2.start(); t3.start(); } }
6、线程同步
1）出现的问题：
· 相同的票出现多次：CPU的一次操作必须是原子性的
· 还出现了负数的票：随机性和延迟导致的
2）解决线程安全问题的基本思想
· 首先想为什么出现问题?(也是我们判断是否有问题的标准)
A：是否是多线程环境
B：是否有共享数据
C：是否有多条语句操作共享数据
· 如何解决多线程安全问题呢?
· 基本思想：让程序没有安全问题的环境。
· 怎么实现呢?
· 把多个语句操作共享数据的代码给锁起来，让任意时刻只能有一个线程执行即可。
3）解决线程安全问题实现1：同步代码块
格式：
synchronized(对象){需要同步的代码;}
同步可以解决安全问题的根本原因就在那个对象上。该对象如同锁的功能。
同步代码块是把多条语句操作共享数据的代码的部分给包起来。
package threaddemos; /** * Created by gao on 16-1-4. */ public class SellTicket3 implements Runnable { // 定义100张票 private int tickets = 50; //创建锁对象 private Object obj = new Object(); @Override public void run() { while (true) { synchronized (obj) { if (tickets > 0) { try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + "正在出售第" + (tickets--) + "张票"); } } } } // @Override // public void run() { // // while (true) { // if (tickets > 0) { // System.out.println(Thread.currentThread().getName() + "---" + "正在出售第" + (tickets--) + "张票"); // } // } // } } 测试类： package threaddemos; /** * Created by gao on 16-1-4. */ /* * 实现Runnable接口的方式实现 */ public class SellTicketDemo3 { public static void main(String[] args) { // 创建资源对象 SellTicket3 st = new SellTicket3(); // 创建三个线程对象 Thread t1 = new Thread(st,"窗口1"); Thread t2 = new Thread(st,"窗口2"); Thread t3 = new Thread(st,"窗口3"); // 启动线程 t1.start(); t2.start(); t3.start(); } }
4）同步的特点
· 同步的前提
· 多个线程
· 多个线程使用的是同一个锁对象
· 同步的好处
· 同步的出现解决了多线程的安全问题。
· 同步的弊端
· 当线程相当多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低程序的运行效率。
5）解决线程安全问题实现2
package threaddemos; /** * Created by gao on 16-1-4. */ public class SellTicket4 implements Runnable { // 定义100张票 private static int tickets = 100; // 定义同一把锁 private Object obj = new Object(); private Demo d = new Demo(); private int x = 0; //同步代码块用obj做锁 // @Override // public void run() { // while (true) { // synchronized (obj) { // if (tickets > 0) { // try { // Thread.sleep(100); // } catch (InterruptedException e) { // e.printStackTrace(); // } // System.out.println(Thread.currentThread().getName() // + "正在出售第" + (tickets--) + "张票 "); // } // } // } // } //同步代码块用任意对象做锁 // @Override // public void run() { // while (true) { // synchronized (d) { // if (tickets > 0) { // try { // Thread.sleep(100); // } catch (InterruptedException e) { // e.printStackTrace(); // } // System.out.println(Thread.currentThread().getName() // + "正在出售第" + (tickets--) + "张票 "); // } // } // } // } @Override public void run() { while (true) { if(x%2==0){ //加载class文件当锁 synchronized (SellTicket.class) { if (tickets > 0) { try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + "正在出售第" + (tickets--) + "张票 "); } } }else { // synchronized (d) { // if (tickets > 0) { // try { // Thread.sleep(100); // } catch (InterruptedException e) { // e.printStackTrace(); // } // System.out.println(Thread.currentThread().getName() // + "正在出售第" + (tickets--) + "张票 "); // } // } sellTicket(); } x++; } } // private void sellTicket() { // synchronized (d) { // if (tickets > 0) { // try { // Thread.sleep(100); // } catch (InterruptedException e) { // e.printStackTrace(); // } // System.out.println(Thread.currentThread().getName() // + "正在出售第" + (tickets--) + "张票 "); // } // } // } //如果一个方法一进去就看到了代码被同步了，那么我就再想能不能把这个同步加在方法上呢? // private synchronized void sellTicket() { // if (tickets > 0) { // try { // Thread.sleep(100); // } catch (InterruptedException e) { // e.printStackTrace(); // } // System.out.println(Thread.currentThread().getName() // + "正在出售第" + (tickets--) + "张票 "); // } // } private static synchronized void sellTicket() { if (tickets > 0) { try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + "正在出售第" + (tickets--) + "张票 "); } } } class Demo { }
测试类：
package threaddemos; /** * Created by gao on 16-1-4. */ /* * 实现Runnable接口的方式实现 */ /* * A:同步代码块的锁对象是谁呢? * 任意对象。 * * B:同步方法的格式及锁对象问题? * 把同步关键字加在方法上。 * * 同步方法是谁呢? * this * * C:静态方法及锁对象问题? * 静态方法的锁对象是谁呢? * 类的字节码文件对象。 */ public class SellTicketDemo4 { public static void main(String[] args) { // 创建资源对象 SellTicket3 st = new SellTicket3(); // 创建三个线程对象 Thread t1 = new Thread(st,"窗口1"); Thread t2 = new Thread(st,"窗口2"); Thread t3 = new Thread(st,"窗口3"); // 启动线程 t1.start(); t2.start(); t3.start(); } }
6）以往的线程安全类
package cn.itcast_12; import java.util.ArrayList; import java.util.Collections; import java.util.Hashtable; import java.util.List; import java.util.Vector; public class ThreadDemo { public static void main(String[] args) { // 线程安全的类 StringBuffer sb = new StringBuffer(); Vector<String> v = new Vector<String>(); Hashtable<String, String> h = new Hashtable<String, String>(); // Vector是线程安全的时候才去考虑使用的，但是不会用Vector，而是用下面的。 // public static <T> List<T> synchronizedList(List<T> list) List<String> list1 = new ArrayList<String>();// 线程不安全 List<String> list2 = Collections .synchronizedList(new ArrayList<String>()); // 线程安全 } }