Edgar--Demo1

package Thread;

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

/*
 * 多线程
 * 1.理解进程与线程关系
 *   进程就是正在执行的程序，在内存中一块区域  
 *   线程组织起进程（一个进程可以有一个线程）
 * 2.线程的几种状态（os笔记有说）
 * 
 * 3.单线程 效率低 安全性高
 * 	 多线程 效率高 安全性低
 * 4.同步问题
 *  .目录 
 *  线程的实现 
 *  java单线程的局限 使我们无法再继承其他的类 而且重写run到类中 复用性一般 耦合性大
 *  所以我们常用接口来实现  或者我们直接使用匿名内部类 （如果我们只是要使用一次的话）
 
 * 
 */

public class Demo1 extends Thread {
	public static void main(String[] args) throws InterruptedException, ExecutionException {
		//第一种 继承thread
		// 创建对象调用方法
		MyThread thread = new MyThread();
		thread.start();
		// 通知jvm线程进入就绪状态 当cpu给其分配资源的时候执行
		//第二种 实现runable
		Thread thread2=new Thread(new MyThread2());
		thread2.start();
		//第三种 实现callable
		Mythread3 mythread3=new Mythread3();
		FutureTask<String> ft=new FutureTask<String>(mythread3);
		ft.run();//这是callable的启动线程
		//callable--get方法是阻塞方法 如果线程没有返回结果 线程会一直阻塞
		//我们在run里面写一个非常长时间的睡眠会观察到阻塞现象（---一直不输出）
		String string=ft.get();
		System.out.println("----");
		System.out.println(string);
	}
}
class MyThread extends Thread {
	@Override
	public void run() {
		// TODO Auto-generated method stub
		for (int i = 0; i < 3; i++) {
		try {
			Thread.sleep(200);//我们把睡眠时间开大点 开到1 秒 睡眠 让另一个进程去执行 这样看起来像交换执行
			//这就是让线程进行睡眠的一个方法  期间其他线程如果没有睡眠 正常运行
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
			System.out.println("你瞅啥");
	}
	}
}
//第二种实现多线程的方法 （注意这种方式不通过start启动，因为接口里并没有这个方法）
//注意runnable只是一个接口,其中只有一个run的抽象方法,我们用这种方式重写的run 直接调用相当于普通方法的调用
//所以我们要用 线程类来接受这个实现这个接口的类

//本身thread类是实现run这个接口 重写了run方法 而且thread包含很多其他方法

/*Thread里面的run的定义（在run里重写或者写一个实现runnable的实例化对象放进传参，他就帮你跑）
 * 定义了当目标线程不为空的时候 
 * 执行这个线程任务
 */
class MyThread2 implements Runnable {
	@Override
	
	public void run() {
		for (int i = 0; i < 3; i++) {
		// TODO Auto-generated method stub
		try {
			Thread.sleep(200);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
			System.out.println("瞅你咋地");
	}
	}
}
//第三种方式 callable 对比runable来讲 方法可以有返回值 对应callable有泛型支持
//（前两种的run都是void类型），并且可以抛出异常可以在run 后面抛出（不用在run里抓了？）
//执行这种线程，需要FutureTask实现类的支持，用于接收运算结果
//这种不太常用了
class Mythread3 implements Callable<String>{
 	@Override
	public String call() throws Exception {
		 
		 Thread.sleep(1000);
		 return "OK";
	}
	
}

//其他--直接放在函数里面执行
//具体实现可以使用匿名内部类 临时使用使用一次
//		Thread thread00=new Thread(){
//			public void run() {
//				System.out.println();
//				try {
//					name1();
//				} catch (InterruptedException e) {
//					// TODO Auto-generated catch block
//					e.printStackTrace();
//				}
//			}
//		};