* A：什么是线程
* 线程是程序执行的一条路径，一个进程中可以包含多条线程
* 多线程并发执行可以提高程序的效率，可以同时完成多项工作
* B：多线程的应用场景
* 红蜘蛛同时共享屏幕给多个电脑
* 迅雷开启多条线程一起下载
* QQ同时和多个人一起视频
* 服务器同时处理多个客户端请求
* 并行就是两个任务同时运行，就是甲任务进行的同时，乙任务也同时进行（需要多核CPU）
* 并发是指两个任务都请求运行，而处理器只能接收一个任务，于是就安排轮流执行这两个任务，由于时间间隔较短，因此用户感觉两个任务同时运行
* 比如：我和两个网友聊天，左手操作一个电脑，右手操作另一个电脑，就叫并行
* 如果用一台电脑先给一个人发消息，再用这台电脑给另一个人发消息，这就叫并发
* 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("垃圾被清扫了"); } }
* 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"); } } }
* 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(); // 开启线程 } }
* 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 纳秒
原文：https://www.cnblogs.com/zhaochuming/p/12722082.html
