三、并发编程之创建线程的多种方式

1、继承Thread类

/**
 * 1、创建线程  继承Thread类
 * */
public class Demo1 extends Thread{

	public Demo1(String name){
		super(name);
	}
	/**
	 * 1、守护线程
	 * */
//	@Override
//	public void run() {
//		while(true) {
//			System.out.println(getName()+"线程执行了。。。");
//		}
//	}
	
	/**
	 * 2、中断线程 interrupt
	 * */
	@Override
	public void run() {
		while(!interrupted()) {// 线程是否是中断状态
			System.out.println(getName()+"线程执行了。。。");
			try {
				Thread.sleep(2000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
	public static void main(String[] args) {
		Demo1 d1 = new Demo1("first-thread");
		Demo1 d2 = new Demo1("second-thread");
		/**
		 * 1、守护线程
		 * 在Java中有两类线程：用户线程 (User Thread)、守护线程 (Daemon Thread)。 
		 *	守护线程，是指在程序运行的时候在后台提供一种通用服务的线程，比如垃圾回收线程就是一个很称职的守护者，并且这种线程并不属于程序中不可或缺的部分。因此，当所有的非守护线程结束时，程序也就终止了，同时会杀死进程中的所有守护线程。反过来说，只要任何非守护线程还在运行，程序就不会终止。
		 *	用户线程和守护线程两者几乎没有区别，唯一的不同之处就在于虚拟机的离开：如果用户线程已经全部退出运行了，只剩下守护线程存在了，虚拟机也就退出了。 因为没有了被守护者，守护线程也就没有工作可做了，也就没有继续运行程序的必要了。
		 *	将线程转换为守护线程可以通过调用Thread对象的setDaemon(true)方法来实现。
		 *	在使用守护线程时需要注意一下几点：
		 *	(1) thread.setDaemon(true)必须在thread.start()之前设置，否则会跑出一个IllegalThreadStateException异常。你不能把正在运行的常规线程设置为守护线程。 
		 *	(2) 在Daemon线程中产生的新线程也是Daemon的。
		 *	(3) 守护线程应该永远不去访问固有资源，如文件、数据库，因为它会在任何时候甚至在一个操作的中间发生中断。
		 * */
//				d1.setDaemon(true);//守护线程
//				d2.setDaemon(true);//守护下线程
//				d1.start();
//				d2.start();
//				try {
//					Thread.sleep(2000);
//				} catch (InterruptedException e) {
//					e.printStackTrace();
//				}

		/**
		 * 2、中断线程 interrupt
		 * */
		d1.start();
		d2.start();
		d1.interrupt();//中断线程
	}
}

2、实现Runnable接口

/**
 * 2、创建线程  实现Runnable接口
 * 作为线程任务存在，线程所要执行的功能
 * */
public class Demo2 implements Runnable{
	
	@Override
	public void run() {
		while(true) {
			System.out.println("线程执行了。。。");
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}

	public static void main(String[] args) {
		Demo2 d1 = new Demo2();
		Thread thread = new Thread(d1);//创建线程并指定线程任务
		thread.start();
	}
}

3、匿名内部类的方式

/**
 * 3、创建线程   匿名内部类的方式
 * */
public class Demo3{
	
	public static void main(String[] args) {
//		new Thread() {
//			public void run() {
//				while(true) {
//					System.out.println("线程执行了。。。");
//					try {
//						Thread.sleep(100);
//					} catch (InterruptedException e) {
//						e.printStackTrace();
//					}
//				}
//			}
//		}.start();
		
//		new Thread(new Runnable() {
//			@Override
//			public void run() {
//				while(true) {
//					System.out.println("线程执行了。。。");
//					try {
//						Thread.sleep(100);
//					} catch (InterruptedException e) {
//						e.printStackTrace();
//					}
//				}
//			}
//		}).start();
		
		new Thread(new Runnable() {
			@Override
			public void run() {
				while(true) {
					System.out.println("线程执行了。。。runnable");
					try {
						Thread.sleep(100);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			}
		}) {
			public void run() {
				while(true) {
					System.out.println("线程执行了。。。sub");//执行的是是个线程，子类重写了父类的方法
					try {
						Thread.sleep(100);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			}
		}.start();
	}
}

4、带返回值的线程

/**
 * 4、创建线程   带返回值的线程
 * */
public class Demo4 implements Callable<Integer>{
	@Override
	public Integer call() throws Exception {//类似与run方法
		System.out.println("正在进行紧张的计算。。。");
		Thread.sleep(2000);
		return 1;
	}
	
	public static void main(String[] args) throws InterruptedException, ExecutionException {
		Demo4 d4 = new Demo4();
		FutureTask<Integer> task = new FutureTask<>(d4);//d4封装成一个Runnable
		Thread t = new Thread(task);
		t.start();
		System.out.println("我先干点别的");
		Integer result = task.get();
		System.out.println("线程执行的结果为："+result);
	}
}

5、定时器（quartz）

/**
 * 5、创建线程  定时器（quartz）
 * */
public class Demo5{
	public static void main(String[] args) {
		Timer timer = new Timer();//定时器
		//立刻执行，每隔1秒执行一次
		timer.schedule(new TimerTask() {//定时任务，实现了Runnable接口
			@Override
			public void run() {
				//实现定时任务
				System.out.println("TimerTask is run....");
			}
		},0,1000);
	}
}

6、线程池的实现

/**
 * 6、创建线程  线程池的实现
 * */
public class Demo6{
	public static void main(String[] args) {
		//创建固定容量的线程池
		//Executor threadPool = Executors.newFixedThreadPool(10);
		//创建不固定容量的线程池
		Executor threadPool2 = Executors.newCachedThreadPool();
		for(int i=0;i<100;i++) {
			threadPool2.execute(new Runnable() {//执行线程池
				@Override
				public void run() {
					System.out.println(Thread.currentThread().getName());
				}
			});
		}
	}
}

7、Lambda表达式实现

/**
 * 7、创建线程  Lambda表达式实现
 * */
public class Demo7{
	public int add(List<Integer> values){
		//parallelStream并发流  
		//return values.parallelStream().mapToInt(a -> a).sum(); 
		//并行执行
		values.parallelStream().forEach(System.out::print);
		return 0;
	}
	
	
	public static void main(String[] args) {
		List<Integer> values = Arrays.asList(10,20,30,40);
		int result = new Demo7().add(values);
		System.out.println("计算结果为："+result);
	}
}

8、Spring实现多线程

@Configuration
@ComponentScan("com.syntops.xtprm.common.utils")
@EnableAsync
public class Config {

}

/**
 * 创建线程  Spring实现多线程
 * */
@Service
public class DemoService {
	@Async
	public void a() {
		while(true) {
			System.out.println("a");
			try {
				Thread.sleep(2000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
	@Async
	public void b() {
		while(true) {
			System.out.println("b");
			try {
				Thread.sleep(2000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
	
	public static void main(String[] args) {
		AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(Config.class);
		DemoService ds = ac.getBean(DemoService.class);
		ds.a();
		ds.b();
	}
}