java多线程（持续更新）

1.多线程有什么作用（为什么需要多线程）

1. 单核 CPU 的发展遇到了瓶颈. 要想提⾼算⼒, 就需要多核 CPU. ⽽并发编程能更充分利⽤多核 CPU 资源.
2. 有些任务场景需要 "等待 IO", 为了让等待 IO 的时间能够去做⼀些其他的⼯作（这样可以大大提高工作效率）, 也需要⽤到并发编程
3. 其次, 虽然多进程也能实现并发编程, 但是线程⽐进程更轻量（后面会解释原因**）**
   • 创建线程⽐创建进程更快
   • 销毁线程⽐销毁进程更快
   • 调度线程⽐调度进程更快

2.线程和进程之间的区别和联系

• 进程是系统资源分配的基本单位，包括CPU 内存 硬盘 网络带宽等重要的资源。如果频繁的创建销毁进程，就会频繁的进行资源的申请和内存的释放，就会产生大量的开销。
• 线程又被称作是“轻量级进程”，⼀个线程就是⼀个 "执⾏流". 每个线程之间都可以按照顺序执⾏⾃⼰的代码. 多个线程之间 "同时" 执⾏ 着多份代码.

1. 进程是包含线程的. 每个进程⾄少有⼀个线程存在，即主线程
2. 进程和进程之间不共享内存空间. 同⼀个进程的线程之间共享同⼀个内存空间
3. 进程是系统分配资源的最⼩单位，线程是系统调度的最⼩单位
4. ⼀个进程挂了⼀般不会影响到其他进程. 但是⼀个线程挂了, 可能把同进程内的其他线程⼀起带⾛(整 个进程崩溃，因为该进程可能在多处都需要调用挂了的那个线程)
5. 以吃鸡蛋为例

• 此时的进程是一个人吃100个鸡蛋，速度是很慢的（还会被撑死）

• 此时在开一个进程，两个进程同时进行吃鸡蛋的工作（但创建两个进程开销比较大，且效率不是很高） 

  

• 此时引入多线程，更多的人来吃鸡蛋，此时效率就会很高。
• 但是线程并不是越多越好，cpu的资源是有限的，当线程多了线程之间就会对cpu资源进行竞争（很多人在一张桌子上面吃鸡蛋，离桌子远的的人就会拿不到鸡蛋，就会发生争抢）

3.如何创建多线程

• 上面运用吃鸡蛋的例子说明了多线程的好处，接下来介绍创建多线程的几种方法。

1.继承Thread重写run方法

• 获取线程的引用 Thread.currentThread()

 package classTest1;
  class myThread  extends Thread {
      public void run (){
          while (true) {
              System.out.println("hello thread");
              try {
                  Thread.sleep(1000);
              } catch (InterruptedException e) {
                  e.printStackTrace();
              }
          }
      }
  }
 public class Test {
     public static void main(String[] args) {
         Thread t = new myThread();
         t.start();
         while (true) {
             System.out.println("hello main");
             try {
                 Thread.sleep(1000);
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
     }
 }
 //多线程，进入死循环
 //打印的结果是hello main 比hello thread快一点
 //由于调用线程需要开销，调用start创建线程是需要时间，所以慢
 //但是顺序并不是绝对的，因为线程是类似于“随机调度”，一个线程什么时候被调度到cpu上执行的时机是不确定的

2.实现Runnable接口重写run

package classTest2;

public class myThread implements Runnable{
    @Override
    public void run() {
        System.out.println("hhh");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

package classTest2;

public class Test {
    public static void main(String[] args) throws InterruptedException {
       /*
       * 用类的类型创建对象的过程称为类的实例化
       * myThread实现了runnable接口
       *  Runnable就相当于属于 myThread这个类型
       * 类：共同特征的描述*/
        Runnable r = new myThread();
        //还是需要Thread才能创建出真正的线程
        Thread t = new Thread(r);
        t.start();
        while (true) {
            System.out.println("ggggg");
            Thread.sleep(1000);

        }

    }
}

 

3.继承Thread，重写run，但是使用匿名内部类

package classTest3;

public class Test {
    public static void main(String[] args) {
        /*
         * 使用匿名内部类
         * 匿名 没有名字，意味着只可以使用一次
         *使用该格式创建匿名内部类 ({}中定义的就是匿名内部类）
         * 相当于是Thread的一个子类 */
        Thread t = new Thread() {
            @Override
            public void run() {
                while (true) {
                    System.out.println("lll");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        t.start();
        while(true) {
                System.out.println("gggg");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }


    }
}

4.实现Runnable，重写run匿名内部类

package classTest4;

public class Test {
    public static void main(String[] args) {
        Thread t = new Thread(new Runnable() {
            /*
            * 填写了Runnable打的匿名内部类的实例
            * 与classTest2相似
            * */
            @Override
            public void run() {
                while (true ) {
                    System.out.println("ggg");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
        t.start();
        while (true) {
            System.out.println("hhhhh");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
}

 

5.使用lambda表达式（较为方便的格式）

package classTest5;

import java.awt.*;

public class Test {
    public static void main(String[] args) {
        /*
        * lambda表达式的写法
        * */
        Thread t  = new Thread(() -> {
            while (true) {
                System.out.println("ggg");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

        });
        t.start();
        while (true) {
            System.out.println("hhhh");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        }
    }

总结

• 线程进程的区别
• 线程的优势（多线程编程）
• 注意线程调度的先后顺序是不确定的！！！

ps：个人见解，如有问题希望大佬能帮忙指出，谢谢（后续会持续更新）