java方法写线程什么时候返回 java中线程实现了什么接口

Java中创建多线程有三种方式：

1. 继承Thread类，重新run方法
2. 实现Runnable接口，重写run方法
3. 实现Callable接口（JUC并发包下的实现方式），重写call方法

*根据Java的面向对象思想，注意少用集成多用实现，因为Java是单继承多实现

API:

• Runnable接口：接口由任何类实现，但其实例要由线程（Thread类对象的start()方法来创建线程）执行。实现此接口，就要实现run方法（线程的入口点）
• Thread类：该类也是实现Runnable接口，Java虚拟机允许应用程序同时执行多个执行程序。每个线程都有优先级，但优先级高的线程不代表就优先执行，只是CPU在调度时几率会大一些。

理解概念：用户线程和守护线程都是线程，区别是Java虚拟机在所有用户线程dead后，程序就会结束。而不管是否还有守护线程还在运行，若守护线程还在运行，则会马上结束。很好理解，守护线程是用来辅助用户线程的。由两者的区别及dead时间点可知，守护线程不适合用于输入输出或计算等操作，因为用户线程执行完毕，程序就dead了，适用于辅助用户线程的场景，如JVM的垃圾回收，内存管理都是守护线程，还有就是在做数据库应用的时候，使用的数据库连接池，连接池本身也包含着很多后台线程，监听连接个数、超时时间、状态等

Thrad类中方法：

1. start()：线程开始执行，Java虚拟机调用此线程的run方法
2. run()：实现Runnable接口必须重写的方法，是调用线程执行的方法体

package com.project;

/**
 * 创建线程方法一
 * 1、创建：继承Thread+重写run方法
 * 2、运行：创建子类对象+start方法
 */
public class RunThread extends Thread{

	//线程入口点
	@Override
	public void run() {
		this.active("听歌");
	}
	
	public static void main(String[] args) {
		RunThread thread = new RunThread();
		thread.start();
		thread.active("学习");
	}
	
	private void active(String oper){
		for (int i = 0; i < 20; i++) {
			System.out.println(i + "->" + oper);
		}
	}
}

了解概念：JNI（Java本地接口Java native interface）

start()源码—>start0()：此方法是与CPU打交道的JNI方法，其作用是调用Thread对象中的run()方法

Runnable接口

package com.project;

/**
 * 模拟12306抢票
 * 资源共享，并发（线程安全）
 * 并发问题：
 * 	当一份资源共享，有代理去操作时，操作的资源会有线程安全问题
 *
 */
public class Web12306 implements Runnable{

	int ticketNum = 99;
	/**
	 * run方法没有返回值并且不能堆外抛出异常
	 */
	@Override
	public void run() {
		while(true) {
			if(ticketNum < 0 ) {
				break;
			}
			/*开启后，能看到线程安全问题
			 * try { Thread.sleep(100); } catch (InterruptedException e) {
			 * e.printStackTrace(); }
			 */
			System.out.println(Thread.currentThread().getName()+"-->"+ticketNum--);
		}
	}

	public static void main(String[] args) {
		Web12306 web = new Web12306();
		System.out.println(Thread.currentThread().getName());
		new Thread(web,"张三").start();
		new Thread(web,"李四").start();
		new Thread(web,"王五").start();
	}
}

package com.project;

/**
 * 模拟龟兔赛跑
 * @author chaixf
 *
 */
public class Recer implements Runnable {

	private String winner ;//胜利者
	@Override
	public void run() {
		for(int steps=1;steps<=100;steps++) {
			//模拟兔子休息，跑70步休息了
			if(Thread.currentThread().getName().equals("rebbit") && steps%70==0) {
				try {
					Thread.sleep(10);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			System.out.println(Thread.currentThread().getName() + "-->" + steps);
			
			//比赛是否结束
			boolean flag = gameOver(steps);
			if(flag) {
				break;
			}
		}
	}
	
	private boolean gameOver(int steps) {
		if(winner != null) {
			return true;
		}else {
			if(steps == 100) {
				winner = Thread.currentThread().getName();
				System.out.println("winner => " + winner);
				return true;
			}
		}
		return false;
	}
	
	public static void main(String[] args) {
		Recer recer = new Recer();
		new Thread(recer, "rebbit").start();
		new Thread(recer, "tortoise").start();
	}

}

Callable接口

是JUC并发包中的接口，实现较为复杂，call方法有返回值，也可抛出异常

package com.project;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

/**
 * 模拟龟兔赛跑
 * @author Administrator
 *
 */
public class CRacer implements Callable<Integer>{

	private String winner;//胜利者
	@Override
	public Integer call() throws InterruptedException {
		String animal = Thread.currentThread().getName();
		for(int steps=1;steps<=100;steps++){
			//模拟休息
			if("pool-1-thread-1".equals(animal) && steps%10==0){
				Thread.sleep(100);
			}
			System.out.println(animal + "->" + steps);
			boolean flag = gameOver(steps);
			if(flag){
				return steps;
			}
		}
		return null;
	}
	
	//游戏结束
	private boolean gameOver(int steps){
		if(winner != null){
			return true;
		}else{
			if(steps == 100){
				winner = Thread.currentThread().getName();
				System.out.println(winner +":win,game over");
				return true;
			}
		}
		return false;
	}
	
	public static void main(String[] args) throws InterruptedException, ExecutionException {
		CRacer racer = new CRacer();
		ExecutorService es = Executors.newFixedThreadPool(2);
		Future<Integer> result1 = es.submit(racer);
		Future<Integer> result2 = es.submit(racer);
		Integer r1 = result1.get();
		Integer r2 = result2.get();
		es.shutdown();
		System.out.println(r1 + "-" + r2);
	}

}