Java简单线程创建

1:单核CPU在一小段时间内进行多个任务的执行，就必须使用多线程。

2：进程是指在操作系统中正在运行的一个应用程序，线程是指进程内独立执行某个任务的一个单元

3：进程拥有资源，而线程是使用这些资源的分配和调度的基本单位。

4：进程与进程之间可并发执行，线程与线程之间也可并发执行，线程的并发性更高

5：创建线程引起的系统开销（分配系统资源）远小于创建进程引起的系统开销

1:继承Thread类，通过改写thread的run方法，并调用start方法运行线程

package mytest;


class MyThread extends Thread
{
	private String name;
	
	public MyThread(String name) {

	   this.name=name;
	}
	
	public void run()
	{
		System.out.println("线程"+name+"开始运行");
		for(int i=0;i<5;i++)
		{
			System.out.println("线程"+name+"运行"+i);
		}
		System.out.println("线程"+name+"结束");
	}
}



public class test {
	public static void main(String[] args)
	{
		Thread t1=new MyThread("T1"); //上转型
		t1.start();
		
		Thread t2=new MyThread("T2");
		t2.start();
	}

}

2：实现Runnable接口

所有的线程都是直接或者间接实现Runnale接口的，Thread类就实现了Runnable接口。

package mytest;


class MyThread implements Runnable
{
	private String name;
	private Thread mythread;
	
	public MyThread(String name) {

	   this.name=name;
	}
	
	public void run()
	{
		for(int i=0;i<5;i++)
		{
			System.out.println("线程"+name+"运行"+i);
		}
		System.out.println("线程"+name+"结束");
	}
	
	public void start()
	{
		System.out.println("线程开始： " + name);
		if(mythread==null)  //刚开始的时候，只是声明了mythread并没有创建，因此依旧为null
		{
			mythread=new Thread(this,name);  //将该类实例化为一个线程
			mythread.start();
		}
	}
}



public class test {
	public static void main(String[] args)
	{
		MyThread t1=new MyThread("T1"); 
		t1.start();
		
		MyThread t2=new MyThread("T2");
		t2.start();
	}
}

3:使用Callable和Future创建线程

Callable产生结果，Callable是个泛型接口，含有call()方法与Thread的run()方法不同的是,call()方法具有返回值，Future获取结果

1. 创建 Callable 接口的实现类，并实现 call() 方法，该 call() 方法将作为线程执行体，并且有返回值；

2. 创建 Callable 实现类的实例，使用 FutureTask 类来包装 Callable 对象，该 FutureTask 对象封装了该 Callable 对象的 call() 方法的返回值；

3. 使用 FutureTask 对象作为 Thread 对象的 target 创建并启动新线程；

4. 调用 FutureTask 对象的 get() 方法来获得子线程执行结束后的返回值;

例题：

斐波那契数列（Fibonacci数列） 这个数列从第3项开始，之后的每一项都等于它的前两项数字之和。 这个数列为： 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233，377，610，987，1597，2584，4181，6765，10946，17711，28657，46368........

测试说明

补充完代码后，点击测评，平台会对你编写的代码进行测试，当你的结果与预期输出一致时，即为通过。

输入：3 输出：线程的返回值为：2

输入：5 输出：线程的返回值为：5

Task.java

package step2;

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

public class Task {

	public void runThread(int num) {
    //请在此添加实现代码
/********** Begin **********/
// 在这里开启线程 获取线程执行的结果
    ThreadCallable cts=new ThreadCallable();
    cts.setnum(num);
    FutureTask<Integer> ft =new FutureTask<Integer>(cts);
    new Thread(ft).start();
    try {
    System.out.print("线程的返回值为："+ft.get());
    }catch (Exception e)
    {
    	e.printStackTrace();;
    }

/********** End **********/

	}
}

//请在此添加实现代码
/********** Begin **********/

/* 在这里实现Callable接口及方法 */
class ThreadCallable  implements Callable<Integer>  {
    private int num;
    public void setnum(int num)
    {
        this.num=num;
    } 
    public Integer call() throws Exception{
        int c=-1;
       if(num==1 || num==2)
       {
           return 1;
       }
       else
       {
           int a=1,b=1;
           num=num-2;
           while(num!=0)
           {
               num=num-1;
               c=a+b;
               a=b;
               b=c;
           }
       }
       return c;
    }



}


/********** End **********/

2.Test.java

package step2;

import java.util.Scanner;
import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;
import step2.ThreadCallable;

public class Test {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		
		int num = sc.nextInt();
		
		ThreadCallable callable = new ThreadCallable();
		if(!(callable instanceof Callable)){
			System.out.println("未定义Callable线程，或者定义错误");
		}
		
		Task task = new Task();
		task.runThread(num);
		
	}
}

该方法可获得返回值，但是需要提前了解泛型的知识，不然对于方法的定义很难编写，该三种为Java创建线程的常见方法，按需要去创建线程