Java学习 之 多线程

/*

线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程，一个进程中是可以有多个线程的，这个应用程序称之为多线程

单线程:即有多个任务只能依次执行，当上个任务执行结束后，下个任务开始执行

多线程:即有多个任务可以同时执行

主线程:jvm启动后，必然有一个执行路径(线程)从main方法开始，一直执行到main方法结束，这个线程在java中称之为主线程

多线程:多线程执行时，在栈内存中，其实每一个执行线程都有一片自己所属的栈内存空间，进行方法的压栈和弹栈

*/

/*

Thread类:

构造方法:Thread()分配新的Thread对象

                Thread(String name)分配新的Thread对象，将指定的name作为其线程名称

方法: void  start()使线程开始执行，虚拟机调用该线程的run方法

          void run()该线程要执行的操作

          static void sleep(long millis)在指定的毫秒数内让当前正在执行的线程休眠

创建新执行线程的两种方法:

   1、将类声明为Thread的子类，该子类重写Thread类的run方法，创建对象，开启线程，run方法相当于其他线程的main方法

   2、声明一个实现Runnable接口的类，该类然后实现run方法，然后创建Runnable的子类对象，传入到某个线程的构造方法中，开启线程

*/

public class Demo1{

     public static void main(String[] args){

        //创建自定义线程对象

       MyThread mt = new MyThread("新线程");

      //开启线程

       mt.start();

      //在主方法中执行for循环

     for(int i = 0 ; i < 10 ; i++){

          System.out.println("main线程" + i);

    }

  }

}

//自定义线程类

public class MyThread extends Thread{

     //定义指定线程名称的构造方法

    public MyThread(String name){

         //调用父类的String参数的构造方法，指定线程的名称

         super(name);

      }

     //重写run方法，完成该线程执行的逻辑

    @Override

    public void run(){

       for(int i = 0 ; i < 10 ; i++){

            System.out.println(getName() + "正在执行" + i);
         }

   }

}

/*

获取线程名称:

         static Thread currentThread()返回对当前正在执行的线程对象的引用

         String getName()返回该线程的名称

*/

public class MyThread extends Thread{

   //重写run方法

   public void run(){

     for(int i = 0 ; i < 10 ; i++){

         System.out.println(Thread.currentThread().getName() +", i =" + i);

       }

    public MyThread(String name){

          super(name);

    }

    }

}

public class ThreadDemo{

    public staitc void main(String[] args){

      //创建两个线程任务

     MyThread mt = new MyThread();

     MyThread mt2 = new MyThread();

     mt.run();//没有开启新线程，在主线程调用run方法

     mt2.start();//开启一个新线程，新线程调用run方法

    }

}

/*

实现Runnanle接口:

接口中的方法: void run()使用实现接口Runnable的对象创建一个线程时，启动该线程将导致在独立执行的线程中调用对象的run方法

Thread类构造方法:

     Thread(Runnable target)分配新的Thread对象，以便将target作为其运行对象

     Thread(Runnable target , String name)分配新的Thread对象，以便将target作为其运行对象，将指定的name作为其名称

实现Runnable接口避免了单继承的局限性

*/

public class RunnableDemo{

    public static void main(String[] args){

      //创建线程执行目标类对象

      Runnable run = new MyRunnable();

      //将Runnable接口的子类对象作为参数传递给Thread类的构造函数

      Thread t = new Thread(run);

      Thread t1 = new Thread(run);
      //开启线程

     t.start();

     t1.start();

    for(int i = 0 ; i < 10 ; i++){

       System.out.println("main线程:" + i);

   }

   }

}

//自定义线程执行任务类

public class MyRunnable implements Runnable{

     //定义线程要执行的run方法

    @Override

    public void run(){

       for(int i = 0 ; i < 10 ; i++){

           System.out.println("我的线程:" + i);

       }

   }

}

/*

线程的匿名内部类:使用线程的匿名内部类方式，可以方便的实现每个线程执行不同的线程任务操作
*/

        new Thread(){

              public void run(){

                 for(int i = 0 ; i < 10 ; i++){

                        System.out.println(Thread.currentThread().getName() +" i :"+ i);

                 }

            }

         }.start();



         Runnable r = new Runnable(){

               public void run(){

                   for(int i =0 ; i < 10 ; i++){

                         System.out.println(Thread.currentThread().getName());

                    }

                }

         };

        new Thread(r).start();

/*

线程池:就是一个容纳多个线程的容器，其中的线程可以反复使用，省去了频繁创建线程对象的操作，无需反复创建线程而消耗过多资源

Executors:线程池创建工厂类

   public static ExecutorService newFixedThreadPool(int nThread)返回线程池对象

ExecutorService:线程池类

  Future<?> submit(Runnable task)获取线程池中的某个一个线程对象，并执行

Future接口:用来记录线程任务执行完毕后产生的结果，线程池创建与使用

*/

public class ThreadPoolDemo{

    public static void main(String[] args){

      //创建线程池对象

     ExecutorService es = Executors.newFixedThreadPool(2);//包含2个线程对象

     //创建Runnable实例对象

    MyRunnable mr = new MyRunnable();

    //从线程池中获取线程对象，然后调用MyRunnable中的run()

    es.submit(mr);

    //再获取个线程对象，调用MyRunnable中的run()

   es.submit(r);

   es.submit(r);

  //submit方法调用结束后，程序并不终止，因为线程池控制了线程的关闭，将使用完的线程又归还到了线程池中

  //关闭线程池

  es.shutdown();

   }

}

public class MyRunnable implements Runnable{

   @Override

   public void run(){

      System.out.println("abc");

      try{

          Thread.sleep(2000);

      }catch(Exception e){

           e.printStackTrace();

      }

      System.out.println("a" +Thread.currentThread().getName());

      System.out.println("bc");
  }

}

/*

Callable接口:与Runnable接口功能相似，用来指定线程任务，其中call()方法，用来返回线程任务执行完毕后的结果，call方法可抛异常

 ExecutorService:线程池类
 <T>Future<T> submit(Callable<T> task)获取线程池中的某个一个线程对象，并执行线程中的call()方法
Future接口:用来记录线程任务执行完毕后产生的结果，线程池创建与使用

*/

public class ThreadPoolDemo{

    public static void main(String[] args){

      //创建线程池对象

     ExecutorService es = Executors.newFixedThreadPool(2);//包含2个线程对象

     //创建Runnable实例对象

    MyCallable c = new MyCallable();

    //从线程池中获取线程对象，然后调用MyRunnable中的run()

    es.submit(c);

    //再获取个线程对象，调用MyCallable中的run()

   es.submit(c);

   es.submit(c);

  //submit方法调用结束后，程序并不终止，因为线程池控制了线程的关闭，将使用完的线程又归还到了线程池中

  //关闭线程池

  es.shutdown();

   }

}

public class MyCallable implements Callable{

    @Override

    public Object call() throws Exception{

      System.out.println("abc");

      Thread.sleep(2000);

      System.out.println("a:" + Thread.currentThread().getName());
      System.out.println("bc");
      return null;

   }

}