Java学习笔记（九）多任务，多线程，进程与线程，线程的创建，静态代理

多任务

• 现实中看起来多个任务都在做，其实本质上我们的大脑在同一时间依旧只做了一件事情

多线程

• 原来是一条路，因为车太多，道路阻塞，效率极低，为了提高使用的效率，能够充分利用道路，于是加了多个车道来提高运行效率。
• 多条执行路径，主线程和子线程并行交替执行。

进程与线程（process与Thread）

• 说起进程，就不得不说下程序，程序是指令和数据的有效集合，其本身没有任何运行含义，是一个静态的概念。
• 而进程则是程序的一次执行过程，他是一个动态的概念，是系统资源分配的单位
• 通常在一个进程中可以包含若干个线程，当然一个进程中至少有一个线程，不然没有存在的意义，线程是CPU调度和执行的单位
• ps 很多多线程是模拟出来的，真正的多线程是指有多个cpu，即多核，如服务器，如果是模拟出来的多线程，即在一个cpu的情况下，在同一时间点，cpu只能执行一个代码，因为切换的很快，所以就有同时执行的错觉。
• 线程就是独立的执行路径；在程序运行时，即使没有自己创建线程，后台也会有个线程，如主线程，gc线程
• main()称之为主线程，是系统的入口，用于执行整个程序
• 在一个进程中，如果开辟了多个线程，线程的运行由调度器安排调度，调度器是与操作系统紧密相关的，先后顺序是不能人为的干预的
• 对同一份资源操作时，会存在资源抢夺的问题，需要加入并发控制
• 线程会带来额外的开销，如cpu调度实践，并发控制开销
• 每个线程在自己的工作内存交互，内存控制不当会造成数据不一致。

线程的创建方式

• Thread class：继承Thread类

  • 将一个类声明为Thread的子类，这个子类来重写run类的方法，然后分配启动子类的实例

  • 步骤：1，自定义线程类继承Thread类。2，重写父类的run()方法，编写线程执行体。3，创建线程对象，调用start()方法启动线程。

  • 启动线程：线程所在类的实例化+.start()

  • package Thread;
    public class StartThread  extends Thread{
             //继承于Thread类
        @Override
        public void run() {
             
            for (int i = 0; i < 100; i++) {
             
                System.out.println("我在看代码");
            }
        }//重写了run方法，里面编写执行程序
        public static void main(String[] args) {
             
            StartThread test = new StartThread();//实例化了子类
            test.start();//调用start()方法启动线程
            for (int i = 0; i < 200; i++) {
             
                System.out.println("我在学习多线程");
            }
        }
    }
    

• Runnable接口：实现Runnable接口

  • 定义自己的类来实现Runnable接口

  • 实现run（）方法，编写线程执行体

  • 创建线程对象，调用start()方法启动线程

  • 推荐使用Runnable的方法来实现多线程，因为Java单继承具有局限性

  • 启动线程：实例化线程所在类+new Thread(*).start

  • package Thread;
    public class MyRunnable implements Runnable{
             
        @Override
        public void run() {
             //重写run
            for (int i = 0; i < 100; i++) {
             
                System.out.println("我在看代码");
            }
        }
        public static void main(String[] args) {
             
            MyRunnable myrun =new MyRunnable();
            //Thread test = new Thread(myrun);
            //test.start();
            new Thread(myrun).start();//两步骤看作一步骤，实例化启动线程线程
            for (int i = 0; i < 200; i++) {
             
                System.out.println("我正在学习多线程");
            }
        }
    }
    

    在进行多线程操作时，提供Thread.currentThread().getName()的方法来拿到每个线程的name。

    多线程在操作统一资源的情况下，线程不安全，会出现数据紊乱的情况

• Callable接口（了解）

  • 实现Callbble接口，需要返回值类型
  • 重写call方法，需要抛出异常
  • 船舰目标对象
  • 创建执行服务：ExcutorService ser=Executors.newFixedThreadPool(1)
  • 提交执行：Futureresult1=ser.submit(t1)
  • 获取结果：boolean r1=result1.get()
  • 关闭夫区：ser.shutdownNow()

静态代理

• 真实对象和代理对象都要实现同一个接口

• 代理对象通过构造的真实对象的target来实现真实对象做的事情，同时代理对象类里完成真实对象所做之外的事情

• 代理对象要代理真实角色

• 好处：代理对象可以做很多真实对象做不了的事情

• 真实对象可以专注做自己的事情

• package Thread;
  public class StaticProxy {
         
      public static void main(String[] args) {
         
          company company = new company(new You());//实例化自身后放入代理再进行代理的实例
          company.HMarry();
      }
  }
  interface Marry{
         
      void HMarry();
  }//创建一个实现线程的接口用来统一代理和自身
  class You implements Marry{
         
      @Override
      public void HMarry() {
         
          System.out.println("我要结婚了happy");
      }//自身重写接口方法
  }//真实对象类在接口中实现真实对象的方法
  class company implements Marry{
         //代理类实现接口
      private Marry target;//创建私有属性target用来连接真实对象
      public company(Marry target) {
         
          this.target = target;
      }//构造初始化target
      @Override//代理方重写接口方法
      public void HMarry() {
         
          before();//代理方独家方法
          this.target.HMarry();//通过target指向来访问所指向的被代理者的接口方法
          after();//代理方独家方法
      }
      public void before(){
         
          System.out.println("布置婚礼");
      }
      public void after(){
         
          System.out.println("收尾款");
      }
  }