多线程：
    如果程序只有一条执行路径，那么该程序就是单线程程序。
    如果程序有多条执行路径，该程序就是多线程程序。

进程：
    正在运行的程序就是进程
    进程是系统进行资源分配和调用的独立单位，每一个进程都有它自己的内存空间和系统资源。

多进程意义：
    单进程的计算机同一时间只能做一件事情,现在的计算机可以做很多事情。
    也就是说现在的计算机支持多进程，可以在同一时间段内执行多个任务。并且提高CPU的使用率。

    一边打游戏，一边听音乐，不是同时进行的，单CPU在某一时间点上只能做一件事。
    CPU在做程序间的高效切换让我们感觉打游戏和听音乐是同时进行的。

    一个程序只有一条执行路径，称为单线程程序。
    一个程序有多条执行路径，称为多线程程序。

什么是线程：
    同一进程内又可以执行多个任务，而这每一个任务就可以看成一个线程。
    线程是程序的执行单元，执行路径。是程序使用CPU的最基本单位。

多线程的意义：
    多线程的存在，不是为了提高程序的执行速读，是为了提高应用程序的使用率。
    程序的执行其实就是在抢CPU的资源，CPU的执行权。
    多个进程在抢资源的时候，其中某一个进行的执行路径比较多，就会有更高的几率抢到CPU的执行权。
    但是不能保证的是哪一个线程在哪个时刻抢到执行权，所以线程的执行有随机性。

并发和并行的区别：
    并发是逻辑上同时发生，指在某一时间内同时运行多个程序。
    并发是物理上同时发生，指在某一时间点同时运行多个程序。

JAVA程序运行原理：
    java命令会启动java虚拟机，启动JVM就等于启动了一个应用程序，也就是一个进程，
    这个进行自动启动一个“主进程”，然后主进程调用某个类的main方法。所以main方法运行在主线程中。

JAVA虚拟机的启动是多线程的，除了主线程，至少还需要垃圾回收线程，否则内存很快就会溢出。

如何实现多线程？
    线程是依赖进程存在的，应该先创建一个进程出来。
    进程是由系统创建的，应该调用系统功能创建一个进程。
    java不能直接调用系统功能，所以没有办法直接实现多线程程序
    但是java可以调用C/C++写好的程序实现多线程程序。
    由C/C++去调用系统能创建进程，然后由java去调用。
    java再提供一些类供我们使用，这就可以实现多线程了。

方式1：继承Thread类
自定义MyThread()方法

1. package com.kxg_01;
   
2. public class MyThread extends Thread {
   
3.         @Override
   
4.         // 重写run()方法，不是类中的所有代码都需要被线程执行，这个时候，为了区分哪些代码能够被线程执行，
   
5.         // java提供了Thread类中的run()方法用来包含那些被线程执行的代码。
   
6.         public void run() {
   
7.                 for (int i = 0; i < 100; i++) {
   
8.                         System.out.println(getName() + ":" + i);//getName()方法是Thread类中获取线程名称
   
9.                 }
   
10.         }
    
11. }

复制代码

创建线程对象并启动

1. package com.kxg_01;
   
2. 
   
3. /*
   
4. * 需求：继承Thread实现多线程的程序
   
5. *
   
6. * 步骤：
   
7. *                 1.自定义MyThread类继承Threa类
   
8. *                 2.重写Thread类中的run()方法
   
9. *                 3.创建对象
   
10. *                 4.启动线程
    
11. */
    
12. public class TreadDemo {
    
13.         public static void main(String[] args) {
    
14.                 MyThread m1 = new MyThread();
    
15.                 MyThread m2 = new MyThread();
    
16. 
    
17.                 // m1.run();
    
18.                 // m2.run();
    
19.                 // 调用run()方法不是开始线程，这样调用相当于调用了一个普通的run()方法
    
20. 
    
21.                 // 用start()方法启动线程
    
22.                 m1.start();
    
23.                 m2.start();
    
24.         }
    
25. }

复制代码

run()方法封装被线程执行的代码，直接调用是普通方法。
start()方法先启动了线程，然后再由JVM调用该线程的run()方法。

获取和设置线程名称：

1. package com.kxg_01;
   
2. public class MyThread extends Thread {
   
3. 
   
4.         public MyThread() {
   
5.         }
   
6. 
   
7. //        定义带参构造方法，Thread类里面有这个带参构造，把参数传递给Thread
   
8.         public MyThread(String name) {
   
9.                 super(name);
   
10.         }
    
11.         public void run() {
    
12.                 for (int i = 0; i < 100; i++) {
    
13.                         System.out.println(getName() + ":" + i);
    
14.                 }
    
15.         }
    
16. }

复制代码

1. package com.kxg_01;
   
2. public class TreadDemo {
   
3.         public static void main(String[] args) {
   
4.                 MyThread m1 = new MyThread();
   
5.                 MyThread m2 = new MyThread();
   
6. 
   
7.                 // 通过带参构造定义线程名称
   
8.                 // MyThread m3 = new MyThread("广州");
   
9.                 // MyThread m4 = new MyThread("深圳");
   
10. 
    
11.                 // 通过Thread类中的setName()方法定义线程名称
    
12.                 m1.setName("北京");
    
13.                 m2.setName("上海");
    
14. 
    
15.                 m1.start();
    
16.                 m2.start();
    
17.         }
    
18. }
    

复制代码

设置线程优先级：

1. package com.kxg_02;
   
2. 
   
3. /*
   
4. * 设置线程优先级
   
5. *                 public final void setPriority(int newPriority)
   
6. *
   
7. * 注意：       
   
8. *                 线程默认优先级是5
   
9. *                 线程优先级范围为1-10
   
10. *                 优先级高仅仅代表该线程获取的CPU时间片的几率高一些，多次运行才能有好的效果
    
11. */
    
12. public class TreadDemo {
    
13.         public static void main(String[] args) {
    
14.                 // 创建线程
    
15.                 MyThread m1 = new MyThread();
    
16.                 MyThread m2 = new MyThread();
    
17. 
    
18.                 // 设置线程名称
    
19.                 m1.setName("北京");
    
20.                 m2.setName("上海");
    
21. 
    
22.                 // 设置线程优先级
    
23.                 m1.setPriority(1);
    
24.                 m1.setPriority(10);
    
25. 
    
26.                 // 启动线程
    
27.                 m1.start();
    
28.                 m2.start();
    
29.         }
    
30. }

复制代码

设置线程休眠时间：

1. package com.kxg_03;
   
2. public class MyThread extends Thread {
   
3.         public void run() {
   
4.                 for (int i = 0; i < 100; i++) {
   
5.                         System.out.println(getName() + ":" + i);
   
6.                         // public static void sleep(long millis)：设置休眠时间，单位为毫秒
   
7.                         try {
   
8.                                 Thread.sleep(1000);
   
9.                         } catch (InterruptedException e) {
   
10.                                 e.printStackTrace();
    
11.                         }
    
12.                 }
    
13.         }
    
14. }

复制代码

加入线程：

1. package com.kxg_04;
   
2. 
   
3. /*
   
4. * public final void join()：等待该线程终止。
   
5. *                 别的线程需要等待这个加入的线程执行结束才能执行。
   
6. */
   
7. public class TreadDemo {
   
8.         public static void main(String[] args) {
   
9.                 // 创建线程
   
10.                 MyThread m1 = new MyThread();
    
11.                 MyThread m2 = new MyThread();
    
12.                 MyThread m3 = new MyThread();
    
13. 
    
14.                 // 设置线程名称
    
15.                 m1.setName("北京");
    
16.                 m2.setName("上海");
    
17.                 m3.setName("广州");
    
18. 
    
19.                 // 启动线程
    
20.                 m1.start();
    
21.                 // 加入线程
    
22.                 try {
    
23.                         m1.join();
    
24.                 } catch (InterruptedException e) {
    
25.                         e.printStackTrace();
    
26.                 }
    
27.                 m2.start();
    
28.                 m3.start();
    
29.         }
    
30. }

复制代码

好东西，留着看

礼让线程：执行效果就是两个线程你一次，我一次的执行

1. package com.kxg_05;
   
2. public class MyThread extends Thread {
   
3.         public void run() {
   
4.                 for (int i = 0; i < 100; i++) {
   
5.                         System.out.println(getName() + ":" + i);
   
6. 
   
7.                         // public static void yield()：暂停当前正在执行的线程对象，并执行其他线程。也称为礼让线程
   
8.                         Thread.yield();
   
9.                 }
   
10.         }
    
11. }

复制代码

守护线程：

1. package com.kxg_06;
   
2. 
   
3. /*
   
4. * public final void setDaemon(boolean on)：将该线程标记为守护线程或用户线程。
   
5. *                 当正在运行的线程都是守护线程时，Java 虚拟机退出。该方法必须在启动线程前调用。
   
6. */
   
7. 
   
8. public class TreadDemo {
   
9.         public static void main(String[] args) {
   
10.                 // 创建线程
    
11.                 MyThread m1 = new MyThread();
    
12.                 MyThread m2 = new MyThread();
    
13. 
    
14.                 // 设置守护线程
    
15.                 m1.setDaemon(true);
    
16.                 m2.setDaemon(true);
    
17.                 // 设置线程名称
    
18.                 m1.setName("深圳");
    
19.                 m2.setName("上海");
    
20. 
    
21.                 // 启动线程
    
22.                 m1.start();
    
23.                 m2.start();
    
24. 
    
25.                 // 设置当前运行线程名称
    
26.                 Thread.currentThread().setName("北京");
    
27.                 for (int i = 0; i < 10; i++) {
    
28.                         // Thread.currentThread().getName():当前执行的线程的名称
    
29.                         System.out.println(Thread.currentThread().getName() + ":" + i);
    
30.                 }
    
31.         }
    
32. }

复制代码

m1,m2设置称为守护线程，当前运行主线程结束的时候，m1,m2都会随之结束。但已经抢到了执行权，不可能立马结束，会稍微运行一下。

中断线程：

1. package com.kxg_06;
   
2. 
   
3. /*
   
4. * 中断线程：
   
5. *                 public void interrupt()
   
6. */
   
7. 
   
8. public class TreadDemo {
   
9.         public static void main(String[] args) {
   
10.                 // 创建线程
    
11.                 MyThread m1 = new MyThread();
    
12.                 MyThread m2 = new MyThread();
    
13. 
    
14.                 // 设置线程名称
    
15.                 m1.setName("深圳");
    
16.                 m2.setName("上海");
    
17. 
    
18.                 // 中断线程，后面的线程还可以继续运行
    
19.                 m1.interrupt();
    
20.                 // 启动线程
    
21.                 m2.start();
    
22.         }
    
23. }

复制代码

线程生命周期：

方式2：通过实现Runnable接口的实现类

1. package com.kxg_07;
   
2. /*
   
3. * 实现Runnable接口
   
4. */
   
5. public class MyRunnable implements Runnable {
   
6. 
   
7.         @Override
   
8.         public void run() {
   
9.                 for (int i = 0; i < 100; i++) {
   
10.                         System.out.println(Thread.currentThread().getName() + ":" + i);
    
11.                 }
    
12.         }
    
13. }

复制代码

1. package com.kxg_07;
   
2. 
   
3. /*
   
4. * 实现Runnable接口
   
5. * 步骤：
   
6. *                 1.自定义类MyRunnable实现Runnabe接口
   
7. *                 3.创建MyRunnable对象
   
8. *                 4.创建Thread类的对象，把MyRunnable对象作为构造参数传递
   
9. */
   
10. public class RunnableDemo {
    
11.         public static void main(String[] args) {
    
12.                 // 创建对象
    
13.                 MyRunnable mr = new MyRunnable();
    
14. 
    
15.                 // 设置线程
    
16.                 Thread t1 = new Thread(mr);
    
17.                 Thread t2 = new Thread(mr);
    
18. 
    
19.                 // 设置线程名称
    
20.                 t1.setName("深圳");
    
21.                 t2.setName("上海");
    
22. 
    
23.                 // 启动线程
    
24.                 t1.start();
    
25.                 t2.start();
    
26.         }
    
27. }

复制代码

方式2好处：
1.可以避免由于java单继承带来的局限性
2.适合多个相同程序的代码去处理同一个资源的情况，
把线程和程序的代码，数据有效分离，较好的体现了面向对象的设计思想。

判断线程是否有问题的标准
    1.是否是多线程环境
    2.是否有共享数据
    3.是否有多条语句操作共享数据

{:2_31:}！！！！！！！！！！！！！！！！！！！！！

线程的状态转换图及常见执行情况：

方式3：实现Callable接口，需要和线程池结合使用
实现类：

1. package com.kxg_06;
   
2. import java.util.concurrent.Callable;
   
3. 
   
4. /*
   
5. * Callable<V>:带泛型的接口
   
6. *                 接口中只有一个方法：V call()
   
7. *                 接口中的泛型是call()方法的返回值类型
   
8. *
   
9. */
   
10. public class MyCallable implements Callable {
    
11. 
    
12.         @Override
    
13.         public Object call() throws Exception {
    
14.                 for (int i = 0; i < 100; i++) {
    
15.                         System.out.println(Thread.currentThread().getName() + ":" + i);
    
16.                 }
    
17.                 return null;
    
18.         }
    
19. }

复制代码

测试类：

1. package com.kxg_06;
   
2. 
   
3. import java.util.concurrent.ExecutorService;
   
4. import java.util.concurrent.Executors;
   
5. 
   
6. public class MyCallableDemo {
   
7.         public static void main(String[] args) {
   
8.                 // 创建线程池对象
   
9.                 ExecutorService pool = Executors.newFixedThreadPool(2);
   
10. 
    
11.                 // 添加Callable实现类
    
12.                 pool.submit(new MyCallable());
    
13.                 pool.submit(new MyCallable());
    
14. 
    
15.                 // 结束线程池
    
16.                 pool.shutdown();
    
17.         }
    
18. }

复制代码

。。。。。。。。。。。。。。。。。。

更加深刻懂了多线程。