java多线程异步简单例子 java多线程执行

多线程的目的

多线程能满足程序员编写高效率的程序来达到充分利用 CPU 的目的。

并发 和并行

并发： 提高单处理器上的程序运行效率

并行： 多个cpu.

线程 和 进程

一条线程指的是进程中一个单一顺序的控制流
一个进程中可以并发多个线程，每条线程并行执行不同的任务。

进程：一个进程包括由操作系统分配的内存空间，包含一个或多个线程。一个线程不能独立的存在，它必须是进程的一部分。一个进程一直运行，直到所有的非守护线程都结束运行后才能结束。

java 实现多线程的三个方式

• 通过实现 Runnable 接口；
• 通过继承 Thread 类本身；
• 通过 Callable 和 Future 创建线程。

1. 继承Thread类

• 要启动一个线程，是调用start方法
• 启动以后，会自动执行run方法
• 如果没有执行start方法，直接调用run方法，就是普通的方法调用，没有启动多余的线程

package com.javabase;

//实现一个线程的方式 1， 继承Thread类
public class ThreadDemo1 extends Thread{
	//线程启动以后，会自动运行run方法
	public void run(){
		System.out.println("ThreadDemo1>>run");
		System.out.println(Thread.currentThread().getName());
	}
	
	

	public static void main(String[] args) {
		System.out.println(Thread.currentThread().getName());
		// TODO Auto-generated method stub
		ThreadDemo1 t1=new ThreadDemo1();
		//通过执行 start方法启动线程
//		t1.start();
		t1.run();
	}

}

main
ThreadDemo1>>run
main

执行start方法开一个新的线程

package com.javabase;

//实现一个线程的方式 1， 继承Thread类
public class ThreadDemo1 extends Thread{
	//线程启动以后，会自动运行run方法
	public void run(){
		System.out.println("ThreadDemo1>>run");
		System.out.println(Thread.currentThread().getName());
	}
	
	

	public static void main(String[] args) {
		System.out.println(Thread.currentThread().getName());
		// TODO Auto-generated method stub
		ThreadDemo1 t1=new ThreadDemo1();
		//通过执行 start方法启动线程
		t1.start();
//		t1.run();
	}

}

main
ThreadDemo1>>run
Thread-0

2 实现Runnable接口

1. 相对于继承Thread类，推荐使用实现Runnable接口，理由是 java是单继承，但是可以同时实现多个接口。 所以如果通过实现接口的方式来实现多线程，就还可以继承其他的类

package com.javabase;

//实现多线程的第二种方式： 实现runnable接口
public class RunableDemo implements Runnable {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		RunableDemo r1=new RunableDemo();
		Thread t1=new Thread(r1);
		t1.start();
	}

	public void run() {
		// TODO Auto-generated method stub
		System.out.println("RunableDemo>>run");
		System.out.println(Thread.currentThread().getName());
	}

}

RunableDemo>>run
Thread-0

3 通过 Callable 和 Future 创建线程

package com.javabase;

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

public class CallableThreadTest implements Callable<Integer> {
    public static void main(String[] args)  
    {  
    	//创建一个callable类型对象
        CallableThreadTest ctt = new CallableThreadTest(); 
        //用FutureTask包装了callable对象
        FutureTask<Integer> ft = new FutureTask<>(ctt);  
        for(int i = 0;i < 100;i++)  
        {  
            System.out.println(Thread.currentThread().getName()+" 的循环变量i的值"+i);  
            if(i==20)  
            {  
            	//用Thread包装FutureTask，然后通过start方法
            	//启动一个新的线程
                new Thread(ft,"有返回值的线程").start();  
            }  
        }  
        try  
        {  
            System.out.println("子线程的返回值："+ft.get());  
        } catch (InterruptedException e)  
        {  
            e.printStackTrace();  
        } catch (ExecutionException e)  
        {  
            e.printStackTrace();  
        }  
  
    }
    //第三种多线程的实现方式：通过callable接口和FutureTask实现
    //第三种实现方式的好处：1， 线程的call方法可以有返回值，
    // 2， call方法可以往上抛异常
    @Override  
    public Integer call() throws Exception  
    {  
        int i = 0;  
        for(;i<100;i++)  
        {  
            System.out.println(Thread.currentThread().getName()+" "+i);  
        }  
        return i;  
    }  
}