java中的线程基础-2

一.Thread类

Thread类实现了Runnable接口，所以Thread对象也是可运行Runnable对象，同时Thread类也是线程类
Thread类定义

        Thread()//一般用于在Thread类中覆盖定义run方法，可以使用匿名内部类进行定义                Thread(Runnable)//使用最多的情况，run方式是由Runnable参数对象提供
        Thread(String name) //自定义线程名称
        Thread(Runnable,String name)
        由于Runnable接口属于函数式接口，所以一般使用简化写法
Thread t = new Thread(()->{
    System.out.println(Thread.currentThread());
});
t.start();
常见方法：

|               方法               | 说明                                                         |
| :------------------------------: | ------------------------------------------------------------ |
|           void start()           | 使该线程开始执行，注意不是立即执行，不是一般方法调用；Java 虚拟机调用该线程的 run 方法 |
|            void run()            | 线程的执行体                                                 |
|       void setName(String)       | 改变线程名称                                                 |
|      void setPriority(int)       | 更改线程的优先级，Java中线程的优先级可以分为1-10，默认为5    |
|     void setDaemon(boolean)      | 设置守护线程,守护线程是一种用于提供服务的线程，一般线程体中使用的是死循环，会在所有非守护线程退出后自动关闭 |
|   void join()/(long millisec)    | 等待该线程终止的时间最长为 millis 毫秒                       |
|         void interrupt()         | 中断线程，不是中断线程的执行，而是修改中断参数               |
|        boolean isAlive()         | 测试线程是否处于活动状态，活动状态就是线程已经启动且尚未终止。线程处于正在运行或准备开始运行的状态，就认为线程是“存活”的 |
|       static void yield()        | 暂停当前正在执行的线程对象，并执行其他线程                   |
| static void sleep(long millisec) | 在指定的毫秒数内让当前正在执行的线程休眠（暂停执行），此操作受到系统计时器和调度程序精度和准确性的影响 |
|  static Thread currentThread()   | 返回对当前正在执行的线程对象的引用                           |

public class Test1 {
public static void main(String[] args) {
	Thread t1=new Thread(()->{  //run方法不能直接调用，从语法角度上说是可以直接调用，但是直接调用则不是多线程
		for(int i=0;i<10;i++) {
			System.out.println(new Date().getTime());
		}
	});
	t1.start();   //启动线程并不意味着线程立即执行，具体线程什么时候开始运行取决于线程调度机制
	for(int i=0;i<10;i++) {
		System.out.println("Main:"+new Date().getTime());
	}
}
}

二.runnable接口 

Runnable接口只定义了一个方法public void run()，这个方法要求实现
Runnable接口的类实现，Runnable对象称为可运行对象，一个线程的运行
就是执行该对象的run()方法
run()方法没有返回值void，而且不能抛出异常
Thread类中的定义
private Runnable target;
@Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }

public class Test1 {
	public static void main(String[] args) {

		// 简化写法
		new Thread(() -> {
			for (int i = 0; i < 10; i++) {
				System.out.println("。。。。。");
				try {
					Thread.sleep(30);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}).start();
	}
}

class MyRunnable implements Runnable {
	@Override
	public void run() throws Exception {//语法报错，这里不允许抛出异常，如果其中有异常则需要使用try.catch处理
		// 没有返回值，如果需要记录处理结果，需要自己编程处理
	}
}

三.callable和future接口

Callable接口

继承Thread或实现Runnable接口这2种方式都有一个缺陷就是：在执行完任务之后无法
获取执行结果。 

如果需要获取执行结果，就必须通过共享变量或者使用线程通信的方式来达到效果，这样
使用起来就比较麻烦。

call()方法有返回值，这个返回值可以通过泛型进行约束，允许抛出异常

public class Test2 {
	public static void main(String[] args) {

		// 简化写法
		new Thread(new FutureTask<>(() -> {
			for (int i = 0; i < 10; i++) {
				System.out.println("right");
				Thread.sleep(30);// 因为call方法允许抛出异常
			}
			return null;
		})).start();
	}
}

class MyRunnable2 implements Callable<Number> {
	// <>中用于指定返回值类型，必须使用引用类型，不能使用简单类型
	public Number call() throws Exception {// 允许抛出异常
		return null;
	}
}

  Future接口
 * Future表示一个任务的生命周期，并提供了方法来判断是否已经完成或取消以及获取任务
 * 的结果和取消任务等
 * 
 * Future就是对于具体的Runnable或者Callable任务的执行结果进行取消、查询是否完成、
 * 获取结果。必要时可以通过get方法获取执行结果，该方法会阻塞直到任务返回结果。
 * 
 * - cancel方法用来取消任务，如果取消任务成功则返回true，如果取消任务失败则返回
 * false。参数mayInterruptIfRunning表示是否允许取消正在执行却没有执行完毕的任务
 * ，如果设置true，则表示可以取消正在执行过程中的任务。如果任务已经完成，则无论
 * mayInterruptIfRunning为true还是false，此方法肯定返回false，即如果取消已经完
 * 成的任务会返回false；如果任务正在执行，若mayInterruptIfRunning设置为true，则
 * 返回true，若mayInterruptIfRunning设置为false，则返回false；如果任务还没有
 * 执行，则无论mayInterruptIfRunning为true还是false，肯定返回true
 * - isCancelled方法表示任务是否被取消成功，如果在任务正常完成前被取
 * 消成功，则返回 true
 * - isDone方法表示任务是否已经完成，若任务完成，则返回true
 * 有用的方法
 * - get()方法用来获取执行结果，这个方法会产生阻塞，会一直等到任务执行完毕
 * 才返回
 * - get(long timeout, TimeUnit unit)用来获取执行结果，如果在指定时间内，
 * 还没获取到结果，就抛出TimeoutException超时异常。 
 * Future接口的具体实现类
 * public class FutureTask<V> implements RunnableFuture<V>
 * public interface RunnableFuture<V> extends Runnable, Future<V> {
    void run();
}

public class Test3 {
	public static void main(String[] args) throws InterruptedException {
		Future f = new FutureTask(() -> {
			for (int i = 0; i < 1000; i++) {
				System.out.println(Thread.currentThread() + "...start..." + i);
				Thread.sleep(10);  //模拟一个处理过程
				System.out.println(Thread.currentThread() + "...end..." + i);
			}
			return null;
		});
		if (f instanceof Runnable) {
			new Thread((Runnable) f).start();
			int counter = 0;
			while (true) {
				Thread.sleep(20);
				System.out.println("任务是否被取消:" + f.isCancelled() + "--" + counter);
				System.out.println("任务是否执行完毕：" + f.isDone());
				counter++;
				if (counter > 10)
					f.cancel(true);// 取消任务的执行
				if (counter > 50)
					break;
			}
		}
	}
}