JAVA 多线程创建的三种方式

###24.01_多线程(多线程的引入)
* 1.什么是线程
    * 线程是程序执行的一条路径, 一个进程中可以包含多条线程
    * 多线程并发执行可以提高程序的效率, 可以同时完成多项工作
* 2.多线程的应用场景
    * 红蜘蛛同时共享屏幕给多个电脑
    * 迅雷开启多条线程一起下载
    * QQ同时和多个人一起视频
    * 服务器同时处理多个客户端请求
    
###24.02_多线程(多线程并行和并发的区别)
* 并行就是两个任务同时运行，就是甲任务进行的同时，乙任务也在进行。(需要多核CPU)
* 并发是指两个任务都请求运行，而处理器只能按受一个任务，就把这两个任务安排轮流进行，由于时间间隔较短，使人感觉两个任务都在运行。
* 比如我跟两个网友聊天，左手操作一个电脑跟甲聊，同时右手用另一台电脑跟乙聊天，这就叫并行。
* 如果用一台电脑我先给甲发个消息，然后立刻再给乙发消息，然后再跟甲聊，再跟乙聊。这就叫并发。

线程的第一种创建方式

1.继承Thread
    * 定义类继承Thread
    * 重写run方法
    * 把新线程要做的事写在run方法中
    * 创建线程对象
    * 开启新线程, 内部会自动执行run方法
  

public class demo4_xianchen {
	public static void main(String[] args) {
		MyThread mt =new MyThread();     //4,创建Thread类的子类对象
		mt.start();                  //5,开启线程
		
		while(true) {
			System.out.println("我是主线程");
		}
		
	}
}

class MyThread extends Thread {            //1,继承Thread
	public void run() {                //2,重写run方法
		while(true) {           //3,将要执行的代码写在run方法中
			System.out.println("我是线程");
		}
	}
}

线程的第二种创建方式

2.实现Runnable的接口
    * 定义类实现Runnable接口
    * 实现run方法
    * 把新线程要做的事写在run方法中
    * 创建自定义的Runnable的子类对象
    * 创建Thread对象, 传入Runnable
    * 调用start()开启新线程, 内部会自动调用Runnable的run()方法

public class demo5_xianchen2 {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		MyRunalbe mr = new MyRunalbe();          //4,创建Runnable的子类对象
		
		Thread t=new Thread(mr);       //5,将其当作参数传递给Thread的构造函数
		t.start();                     //6,开启线程
		

		while(true) {
			System.out.println("我是主线程");
		}

	}

}

class MyRunalbe implements Runnable{       //1,定义一个类实现Runnable
	@Override
	public void run() {          //2,重写run方法
		while(true) {           //3,将要执行的代码写在run方法中
			System.out.println("我是线程>>>>>>>>>>>>");
		}
		
	}
	
}

结合前面两种方法，我们可以用更简单的方法来创建线程。匿名内部类实现线程。

public class Demo4_Thread {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		new Thread() {										//1,继承Thread类
			public void run() {								//2,重写run方法
				for(int i = 0; i < 1000; i++) {				//3,将要执行的代码写在run方法中
					System.out.println("aaaaaaaaaaaaaa");
				}
			}
		}.start();											//4,开启线程
		
		Thread t2=new Thread(new Runnable() {							//1,将Runnable的子类对象传递给Thread的构造方法
			public void run() {								//2,重写run方法
				for(int i = 0; i < 1000; i++) {				//3,将要执行的代码写在run方法中
					System.out.println("bb");
				}
			}
		}).start();											//4,开启线程
	}

}

线程创建的第三种方法。使用Callable和Future创建线程。

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

      /**
       	* 创建线程的第三种方法。实现Callable接口，重写Call方法
       	*Callable<Integer> 是一个泛型    
       	*Callable  ：一个产生结果。有返回值
       	*Future    ：一个拿到结果
       */
 class TestThread implements Callable<Integer> { /* 1.实现Callable接口 */

		@Override
	public Integer call() throws Exception {    /* 2.重写Call方法 */
			// TODO 自动生成的方法存根
			while(true) {           //3,将要执行的代码写在Call方法中
				System.out.println("我是线程>>>>>>");
			}
			//return null;
		}
	
}
	 

public class demo6_xianchen {
	    public static void main(String[] args) {
	        //4.创建Callable的对象返回值
	    	Callable<Integer> callable =new TestThread();	    	
		    /*5. 创建FutureTask, 将Callable转换成Runnable
		     *FutureTask实现了两个接口，Runnable和Future，所以它既可以作为Runnable被线程执行，
		             * 又可以作为Future得到Callable的返回值 
		     * */
	    	FutureTask<Integer> ft =new FutureTask<Integer>(callable);    	
		    /* 6.创建线程 */
	    	Thread t = new Thread(ft);	    	
		   /* 启动线程 */
	    	t.start();
	    	

			while(true) {
				System.out.println("我是主线程.........");
			}
	    }
	}