多线程· Runnable 和 Thread
多线程的引入
* A：什么是线程
* 线程是程序执行的一条路径，一个进程中可以包含多条线程
* 多线程并发执行可以提高程序的效率，可以同时完成多项工作
* B：多线程的应用场景
* 红蜘蛛同时共享屏幕给多个电脑
* 迅雷开启多条线程一起下载
* QQ同时和多个人一起视频
* 服务器同时处理多个客户端请求
多线程并行和并发的区别
* 并行就是两个任务同时运行，就是甲任务进行的同时，乙任务也同时进行（需要多核CPU）
* 并发是指两个任务都请求运行，而处理器只能接收一个任务，于是就安排轮流执行这两个任务，由于时间间隔较短，因此用户感觉两个任务同时运行
* 比如：我和两个网友聊天，左手操作一个电脑，右手操作另一个电脑，就叫并行
* 如果用一台电脑先给一个人发消息，再用这台电脑给另一个人发消息，这就叫并发
Java程序运行的原理和JVM的启动
* A：Java程序运行原理
* Java命令会启动Java虚拟机，启动JVM就等于启动了一个应用程序，也就是启动了一个进程，
* 该进程会自动启动一个“主线程”，然后主线程区调用某个类的main方法
* B：JVM的启动
* JVM的启动至少启动了垃圾线程和主线程，所以是多线程的
package com.heima.thread; public class Demo1_Thread { // 证明JVM是多线程的 public static void main(String[] args) { for (int i = 0; i < 390000; i++) { new Demo(); } for (int i = 0; i < 10000; i++) { System.out.println("我是主线程的执行代码"); } } } class Demo { // 垃圾清理线程 @Override public void finalize() throws Throwable { System.out.println("垃圾被清扫了"); } }
Thread 实现多线程
* A：继承Thread
* 定义类继承Thread
* 重写 run()方法
* 把新线程要做的事写在 run()方法中
* 创建线程对象
* 开启新线程，内部自动会执行 run()方法
package com.heima.thread; public class Demo2_Thread { public static void main(String[] args) { MyThread mt = new MyThread(); // 创建线程的子类对象 // mt.run(); // 未开启线程 mt.start(); // 使该线程开始执行，开启线程需要时间，类似赛道上的发令枪 for (int i = 0; i < 1000; i++) { // 调用主线程 System.out.println("bb"); // 结果：bb 和 aaaaaa 成块状间隔打印 } } } class MyThread extends Thread { // 继承Thread public void run() { // 重写run方法 for (int i = 0; i < 1000; i++) { // 将想要执行的代码写在run方法中 System.out.println("aaaaaaaaaa"); } } }
Runnable 实现多线程
* A：实现 Runnable
* 定义类实现 Runnable接口
* 实现 run()方法
* 把新线程要做的事写在 run()方法中
* 创建Thread对象，传入Runnable的子类对象
* 调用 start()开启新线程，内部会自动调用 Runnable的 run()方法
package com.heima.thread; public class Demo3_Thread { public static void main(String[] args) { MyRunnable mr = new MyRunnable(); // 创建Runnable子类对象 // Thread t = new Thread(mr); // 将Runnable的子类当作参数传递给Thread // t.start(); // 开启线程 new Thread(mr).start(); // 使用匿名类开启线程 for (int i = 0; i < 1000; i++) { System.out.println("bb"); // 穿插打印 aaaaa 和 bb } } } class MyRunnable implements Runnable { // 定义一个类实现Runnable接口 @Override public void run() { // 重写run方法 for (int i = 0; i < 1000; i++) { // 将想要执行的代码写在run方法中 System.out.println("aaaaaaaaaaaa"); } } }
两种方式的区别
* 查看源码的区别：
* a：继承 Thread，由于子类重写了 Thread类的 run()方法，当调用 start()时，直接找子类的 run()方法
* b：实现 Runnable，构造函数中传入了 Runnable的引用，成员变量记住了它，
start()调用 run()方法时内部判断成员变量 Runnable的引用是否为空，不为空编译时看的是 Runnable的 run()，运行时运行的是子类的 run()方法
* 继承 Thread
* 好处是：可以直接使用 Thread类中的方法，代码简单
* 弊端是：如果已经有了父类，就不能用这种方法
* 实现 Runnable接口
* 好处是：即使自己定义的线程类有了父类也没关系，而且接口是多实现的
* 弊端是：不能直接使用 Thread中的方法，需要先获取到线程对象后，才能得到 Thread的方法，代码复杂
匿名内部类实现多线程的两种方式
* 继承 Thread类
* 实现 Runnable接口
package com.heima.thread; public class Demo4_Thread { // 使用匿名类继承Thread，实现Runnable，来开启多线程 public static void main(String[] args) { new Thread() { // 继承Thread类 public void run() { // 重写run方法 for (int i = 0; i < 1000; i++) { // 将要执行的代码写在run方法中 System.out.println("aaaaaaa"); } } }.start(); // 开启线程 new Thread(new Runnable() { // 实现 Runnable接口 @Override public void run() { // 重写run方法 for (int i = 0; i < 1000; i++) { // 将要执行的代码写在run方法中 System.out.println("bb"); } } }).start(); // 开启线程 } }
Thread 获取线程名和设置线程名
* A：获取名字
* 通过 getName()方法获取线程对象的名字
* B：设置名字
* 通过构造函数传入 String类型的名字
* 通过 setName(String)方法可以设置线程对象的名字
package com.heima.threadmethod; public class Demo1_Name { public static void main(String[] args) { // demo1(); // demo2(); } public static void demo2() { new Thread() { public void run() { this.setName("zwb"); // 使用 setName()方法设置线程名，因为是在类的内部，所以用this关键字表示对此类命名 System.out.println(this.getName()+ " aaaaa"); } }.start(); Thread t1 = new Thread() { public void run() { System.out.println(this.getName()+ " bb"); } }; t1.setName("cly"); // 使用 setName()对线程命名，因为在类外，所以通过对象名调用 t1.start(); } public static void demo1() { new Thread("zwb") { // 通过构造方法给线程命名 public void run() { System.out.println(this.getName() + " aaaaaaa"); // 调用 getName()方法获取线程名 } }.start(); new Thread("cly") { // 通过构造方法给线程命名 public void run() { System.out.println(this.getName() + " bb"); // 调用 getName()方法获取线程名 } }.start(); } }
获取当前线程的对象
* Thread.currentThred()，主线程也可以获取
package com.heima.threadmethod; public class Demo2_CurrentThread { public static void main(String[] args) { new Thread() { public void run() { System.out.println(getName() + " aaaaa"); } }.start(); new Thread(new Runnable() { @Override public void run() { System.out.println(Thread.currentThread().getName() + " bb"); // 获取当前正在执行的线程 } }).start(); Thread.currentThread().setName("zwb"); // 设置当前正在执行的线程的名字，即主线程 System.out.println(Thread.currentThread().getName()); // 获取主线程的名字 } }
休眠线程
* Thread.sleep(毫秒值，纳秒值)，控制当前线程休眠若干毫秒
* 1秒 = 1 000毫秒 = 1 000 000 微秒 = 1 000 000 000 纳秒
package com.heima.threadmethod; public class Demo3_Sleep { public static void main(String[] args) throws InterruptedException { // demo1(); // demo2(); } public static void demo2() { new Thread() { public void run() { for (int i = 0; i < 100; i++) { try { Thread.sleep(30); // 线程睡30毫秒 } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(getName() + " aaaaa"); } } }.start(); // 开启线程1 new Thread() { public void run() { for (int i = 0; i < 100; i++) { try { Thread.sleep(30); // 线程睡30毫秒 } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(getName() + " bb"); } } }.start(); // 开启线程2 } public static void demo1() { for(int i = 20; i >= 0; i--) { try { Thread.sleep(1000); // 线程睡1秒 } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("倒计时 第" + i + "秒"); } } }
守护线程
* setDaemo()，设置一个线程为守护线程，该线程不会单独执行，当其他非守护线程都执行结束后，自动退出
package com.heima.threadmethod; public class Demo4_Daemon { // 非守护线程一旦结束，守护线程也会随之结束 public static void main(String[] args) { Thread t1 = new Thread("cly") { // 创建线程1 public void run() { for (int i = 0; i < 2; i++) { System.out.println(getName() + " aaaa"); } } }; Thread t2 = new Thread("zwb") { // 创建线程2 public void run() { for (int i = 0; i < 50; i++) { System.out.println(getName() + " bb"); } } }; t2.setDaemon(true); // 当传入true就是设置为守护线程 t1.start(); // 开启线程 t2.start(); } }
加入线程
* join()，当前线程暂停，等到指定的线程执行结束后，当前线程再继续
* join(int)，可以等待指定的毫秒之后继续
package com.heima.threadmethod; public class Demo5_Join { public static void main(String[] args) { Thread t1 = new Thread() { public void run() { for (int i = 0; i < 100; i++) { System.out.println(getName() + " aaaaaaaa"); } } }; // 创建线程1 Thread t2 = new Thread() { public void run() { for (int i = 0; i < 100; i++) { if (i == 2) { /*try { t1.join();// t2执行2次之后暂停，等到t1全部执行完之后再让t2执行完剩下的所有 } catch (InterruptedException e) { e.printStackTrace(); }*/ try { t1.join(20); // t2执行2次之后暂停，让t1单独先执行20毫秒，之后两条线程再交替执行 } catch (InterruptedException e) { e.printStackTrace(); } } System.out.println(getName() + " bb"); } } }; // 创建线程2 t1.start(); // 开启线程 t2.start(); } }
礼让线程
* yield 让出CPU
package com.heima.threadmethod; public class Demo6_Yield { public static void main(String[] args) { new MyThread().start(); // 开启线程1 new MyThread().start(); // 开启线程2 } } class MyThread extends Thread { public void run() { for (int i = 0; i < 1000; i++) { if (i % 10 == 0) { // 判断是否满足条件 Thread.yield(); // yield让出CPU，但真正运行时可能不会让 } System.out.println(getName() + " " + i); } } }
设置线程优先级
* setPriority()，设置线程的优先级
package com.heima.threadmethod; public class Demo7_Priority { public static void main(String[] args) { Thread t1 = new Thread() { public void run() { for (int i = 0; i < 100; i++) { System.out.println(getName() + " aaaaaaaa"); } } }; // 创建线程1 Thread t2 = new Thread() { public void run() { for (int i = 0; i < 100; i++) { System.out.println(getName() + " bb"); } } }; // 创建线程2 // t1.setPriority(10); // 设置最大优先级,优先级高的相对先执行 // t2.setPriority(1); // 设置最小优先级 t1.setPriority(Thread.MIN_PRIORITY); // 设置最小的线程优先级，1 t2.setPriority(Thread.MAX_PRIORITY); // 设置最大的线程优先级，10 t1.start(); // 开启线程 t2.start(); } }
同步代码块
* A：什么情况下需要同步
* 当多线程并发，有多段代码同时执行时，我们希望某一段代码执行的过程中CPU不要切换到其他线程工作，这时就需要同步
* 如果两段代码是同步的，那么同一时间只能执行一段，在一段代码没执行结束之前，不会执行另外一段代码
* B：同步代码块
* 使用 synchronized关键字加上一个锁对象来定义一段代码，这就叫同步代码块
* 多个同步代码块如果使用相同的锁对象，那么他们就是同步的
package com.heima.syn; public class Demo1_Synchronized { public static void main(String[] args) { final Printer p = new Printer(); new Thread() { public void run() { int i = 0; while (i < 100) { p.print1(); i++; } } }.start(); // 开启线程1 new Thread() { public void run() { int i = 0; while (i < 100) { p.print2(); i++; } } }.start(); // 开启线程2 } } class Printer { Demo d = new Demo(); public void print1() { synchronized (d) { // 同步代码块的锁机制,锁对象可以是任意的对象,但不能是匿名对象 System.out.print("z"); System.out.print("w"); System.out.print("b"); System.out.println(); } } public void print2() { // synchronized (new Demo()) { // 不能是匿名对象 synchronized (d) { System.out.print("c"); System.out.print("l"); System.out.print("y"); System.out.println(); } } } class Demo { }
同步方法
* 使用 synchronized关键字修饰一个方法，该方法中的所有代码都是同步的
package com.heima.syn; public class Demo2_Synchronized { public static void main(String[] args) { Print2 p = new Print2(); Thread t1 = new Thread() { public void run() { for (int i = 0; i < 1000; i++) { p.print1(); } } }; // 创建线程1 Thread t2 = new Thread() { public void run() { for (int i = 0; i < 1000; i++) { p.print2(); } } }; // 创建线程2 t1.start(); // 开启线程 t2.start(); } } class Print1 { // 非静态的同步方法的锁对象是 this public synchronized void print1() { // 同步方法只需要再方法上加上synchronized即可 System.out.print("z"); System.out.print("w"); System.out.print("b"); System.out.println(); } public void print2() { synchronized (this) { System.out.print("c"); System.out.print("l"); System.out.print("y"); System.out.println(); } } } class Print2 { // 静态的同步方法的锁对象是 字节码对象 也就是 Print2.class 或 getClass() public static synchronized void print1() { System.out.print("z"); System.out.print("w"); System.out.print("b"); System.out.println(); } public void print2() { synchronized (getClass()) { System.out.print("c"); System.out.print("l"); System.out.print("y"); System.out.println(); } } }
线程安全问题
* 多线程并发操作同一数据时，就有可能出现线程安全问题
* 使用绒布技术可以解决这种问题，把操作数据的代码进行同步，不要多个线程一起操作
* 举例：铁路售票
package com.heima.syn; public class Demo3_Ticket { public static void main(String[] args) { new Ticket("1").start(); // 开启线程 new Ticket("2").start(); new Ticket("3").start(); new Ticket("4").start(); } } class Ticket extends Thread { public Ticket() { super(); } public Ticket(String name) { // 有参构造，给线程命名 super(name); } private static int ticket = 1000; // 定义静态的票数，使得变量是公共的 private static Object o = new Object(); // 如果用引用数据类型成员变量当作锁对象,必须是静态的，随着类的加载而加载，也是公共的 public void run() { // 重写 run()方法 while (true) { // 定义无限循环 synchronized (Ticket.class) { // 用字节码对象当作锁对象 if (ticket == 0) { // 判断条件跳出 break; } try { Thread.sleep(1); // 线程1睡,线程2睡,线程3睡,线程4睡 } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(getName() + " 这是第" + ticket-- + "号票"); } } } }
死锁问题
* 多线程同步的时候，如果同步代码嵌套，使用相同的锁，就有可能出现死锁
* 尽量不要嵌套使用
package com.heima.syn; public class Demo5_DeadLock { private static String s1 = "筷子左"; // 锁1 private static String s2 = "筷子右"; // 锁2 public static void main(String[] args) { new Thread() { public void run() { // 重写 run()方法 for (int i = 0; i < 100; i++) { synchronized (s1) { System.out.println(getName() + "：获取" + s1 + " 等待" + s2); synchronized (s2) { System.out.println(getName() + "：拿到" + s2 + "开吃"); } } } } }.start(); // 开启线程1 new Thread() { public void run() { for (int i = 0; i < 100; i++) { synchronized (s2) { System.out.println(getName() + "：获取" + s2 + " 等待" + s1); synchronized (s1) { System.out.println(getName() + "：拿到" + s1 + "开吃"); } } } } }.start(); // 开启线程2 } }
以前的线程安全类的回顾
* A：回顾以前说过的线程安全问题
* 看源码：Vector，StringBuffer，Hashtable，Collections.synchronized(xxx)
* Vector 是线程安全的，ArrayList 是线程不安全的
* StringBuffer 是线程安全的，StringBuilder 是线程不安全的
* Hashtable 是线程安全的，HashMap 是线程不安全的
* Collections.synchronized(xxx)，可以将线程不安全的变成线程安全的