多线程

 1 //自定义测试类
 2 public class Demo01 {
 3     public static void main(String[] args) {
 4         //创建自定义线程对象
 5         MyThread mt = new MyThread();
 6         //开启新线程
 7         mt.start();//线程对象调用start开启线程，并让jvm调用run方法在开启的线程中执行。调用run方法不开启线程，只是调用对象的方法。
 8         //在主方法中执行for循环
 9         for (int i = 0; i < 10; i++) {
10             System.out.println("main线程！"+i);
11         }
12     }
13 }
14 //自定义线程类
15 public class MyThread extends Thread {
16     //定义指定线程名称的构造方法
17     public MyThread(String name) {
18         //调用父类的String参数的构造方法，指定线程的名称
19         super(name);
20     }
21     /**
22      * 重写run方法，完成该线程执行的逻辑
23      */
24     @Override
25     public void run() {
26         for (int i = 0; i < 10; i++) {
27             System.out.println(getName()+"：正在执行！"+i);
28         }
29     }
30 }

 1 //测试类
 2 public class Demo02 {
 3     public static void main(String[] args) {
 4         //创建线程执行目标类对象
 5         Runnable runn = new MyRunnable();
 6         //将Runnable接口的子类对象作为参数传递给Thread类的构造函数
 7         Thread thread = new Thread(runn);
 8         Thread thread2 = new Thread(runn);
 9         //开启线程
10         thread.start();
11         thread2.start();
12         for (int i = 0; i < 10; i++) {
13             System.out.println("main线程：正在执行！"+i);
14         }
15     }
16 }
17 //自定义线程执行任务类
18 public class MyRunnable implements Runnable{
19 
20     //定义线程要执行的run方法逻辑
21     @Override
22     public void run() {
24         for (int i = 0; i < 10; i++) {
25             System.out.println("我的线程：正在执行！"+i);
26         }
27     }
28 }

 1 //方式1：创建线程对象时，直接重写Thread类中的run方法
 2         new Thread() {
 3             public void run() {
 4                 for (int x = 0; x < 40; x++) {
 5                     System.out.println(Thread.currentThread().getName() + "...X...." + x);
 6                 }
 7             }
 8         }.start();
 9 
10 //方式2：使用匿名内部类的方式实现Runnable接口，重新Runnable接口中的run方法
11         Runnable r = new Runnable() {
12             public void run() {
13                 for (int x = 0; x < 40; x++) {
14                     System.out.println(Thread.currentThread().getName() + "...Y...." + x);
15                 }
16             }
17         };
18         new Thread(r).start();

 1 //测试类
 2 public class ThreadPoolDemo {
 3     public static void main(String[] args) {
 4         //1创建线程池对象
 5         ExecutorService service = Executors.newFixedThreadPool(2);//包含2个线程对象
 6         //2创建Runnable子类对象
 7         MyRunnable r = new MyRunnable();
 8         
 9         //自己创建线程对象的方式
10         //Thread t = new Thread(r);
11         //t.start(); ---> 调用MyRunnable中的run()
12         
13         //3提交Runnable接口子类对象
14         service.submit(r);
15         //再获取个线程对象，调用MyRunnable中的run()
16         service.submit(r);
17         service.submit(r);
18 //注意：submit方法调用结束后，程序并不终止，是因为线程池控制了线程的关闭。将使用完的线程又归还到了线程池中
19 
20 　　　　　//关闭线程池
21         //service.shutdown();
22     }
23 }
24 //Runnable接口实现类：略