多线程的创建的使用

一，进程与线程

进程：进程指正在运行的程序。确切的来说，当一个程序进入内存运行，即变成一个进程，进程是处于运行过程中的程序，并且具有一定独立功能。

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

简而言之：一个程序运行后至少有一个进程，一个进程中可以包含多个线程

什么是多线程呢？即就是一个程序中有多个线程在同时执行。

        单线程程序：即，若有多个任务只能依次执行。当上一个任务执行结束后，下一个任务开始执行。如，去网吧上网，网吧只能让一个人上网，当这个人下机后，下一个人才能上网。

       多线程程序：即，若有多个任务可以同时执行。如，去网吧上网，网吧能够让多个人同时上网。

 

二，多线程的创建

第一种方法：   继承Thread类，重写run方法

public class Demo01 {
    public static void main(String[] args) {
        //创建自定义线程对象
        
        //在主方法中执行for循环
        for (int i = 0; i < 10; i++) {
            System.out.println("main线程！"+i);
        }
        MyThread1 mt = new MyThread1();
        //开启新线程
        mt.start();
    }
}
 class MyThread1 extends Thread {
    //定义指定线程名称的构造方法
    
    /**
     * 重写run方法，完成该线程执行的逻辑
     */
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+"：正在执行！"+i);
        }
    }
}

第二种方法：实现Runnable接口，重写run方法，然后把实现类传到一个Thread类中。

public class Demo03 {

    public static void main(String[] args) {
        Runn r1 = new Runn();
        Thread t1 = new Thread(r1);
        Thread t2 = new Thread(r1);
        t1.start();
        t2.start();
        for(int i=0;i<20;i++)
        {
            System.out.println(Thread.currentThread().getName()+" : "+i);
        }
    }
}

class Runn implements Runnable{

    @Override
    public void run() {
        for(int i=0;i<20;i++)
        {
            System.out.println(Thread.currentThread().getName()+" : "+i);
        }
    }
    
}

线程匿名内部类的使用：节省了代码行数

方式1：创建线程对象时，直接重写Thread类中的run方法
        new Thread() {
            public void run() {
                for (int x = 0; x < 40; x++) {
                    
                     System.out.println(Thread.currentThread().getName()
                            + "...X...." + x);
                }
            }
        }.start();

方式2：使用匿名内部类的方式实现Runnable接口，重新Runnable接口中的run方法
       Runnable r = new Runnable() {
        public void run() {
                for (int x = 0; x < 40; x++) {
                    System.out.println(Thread.currentThread().getName()
                            + "...Y...." + x);
                }
            }
        };
        new Thread(r).start();

三，线程池

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

public class ThreadPoolDemo {
    public static void main(String[] args) {
        //创建线程池对象
        ExecutorService service = Executors.newFixedThreadPool(2);//包含2个线程对象
        //创建Runnable实例对象
        MyRunnable r = new MyRunnable();
        
        //自己创建线程对象的方式
        //Thread t = new Thread(r);
        //t.start(); ---> 调用MyRunnable中的run()
        
        //从线程池中获取线程对象,然后调用MyRunnable中的run()
        service.submit(r);
        //再获取个线程对象，调用MyRunnable中的run()
        service.submit(r);
        service.submit(r);
//注意：submit方法调用结束后，程序并不终止，是因为线程池控制了线程的关闭。将使用完的线程又归还到了线程池中

//关闭线程池
        //service.shutdown();
    }
}
//Runnable接口实现类
public class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("我要一个教练");
        
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("教练来了： " +Thread.currentThread().getName());
        System.out.println("教我游泳,交完后，教练回到了游泳池");
    }
}

//通过实现一个Callable也可以实现run方法，并且可以通过Future对象获取返回值
public class ThreadPoolDemo {
	public static void main(String[] args) throws InterruptedException, ExecutionException {
		//创建线程池对象
		ExecutorService threadPool = Executors.newFixedThreadPool(2);
		
		//创建一个Callable接口子类对象
		//MyCallable c = new MyCallable();
		MyCallable c = new MyCallable(100, 200);
		MyCallable c2 = new MyCallable(10, 20);
		
		//获取线程池中的线程，调用Callable接口子类对象中的call()方法, 完成求和操作
		//<Integer> Future<Integer> submit(Callable<Integer> task)
		// Future 结果对象
		Future<Integer> result = threadPool.submit(c);
		//此 Future 的 get 方法所返回的结果类型
		Integer sum = result.get();
		System.out.println("sum=" + sum);
		
		//再演示
		result = threadPool.submit(c2);
		sum = result.get();
		System.out.println("sum=" + sum);
		//关闭线程池(可以不关闭)
		
	}
}
//Callable接口实现类
public class MyCallable implements Callable<Integer> {
	//成员变量
	int x = 5;
	int y = 3;
	//构造方法
	public MyCallable(){
	}
	public MyCallable(int x, int y){
		this.x = x;
		this.y = y;
	}

	@Override
	public Integer call() throws Exception {
		return x+y;
	}
}