这是我参与2022首次更文挑战的第6天，活动详情查看：2022首次更文挑战

Java程序设计多线程

进程&线程

进程是程序的一次动态执行过程

它经历了从代码加载、执行到执行完毕的一个完整过程

这个过程也是进程本身从产生、发展到最终消亡的过程

多进程操作系统能同时运行多个进程（程序），而由于CPU具备分时机制，所以每个进程都能循环获得自己的CPU时间片

由于CPU执行速度非常快，使得所有程序好像是在“同时”运行一样

进程与线程的区别多线程是实现并发机制的一种有效手段

进程和线程一样，都是实现并发的一个基本单位

线程是比进程更小的执行单位，是在进程的基础上进行的进一步划分

多线程是指一个进程在执行过程中可以产生多个更小的程序单元（即线程），这些线程可以同时存在、同时运行，而一个进程可能包含了多个同时执行的线程。

线程的实现

继承Thread类

在Thread子类中，必须明确地覆写Thread类中的run()方法。此方法为线程的主体。

语法：

class 类名称 extends Thread{
	属性...;
	方法...;
	public void run(){
		线程主体;
	}
}

package org.test;
class Test extends Thread{
    public Test(){
    }
    public void run(){
        for(int i=1;i<=5;i++) {
            System.out.println(i);
        }
    }
}
public class Hello {
    public static void main(String[] args) {
        Test a1=new Test();
        Test a2=new Test();
        a1.run();
        a2.run();
    }
}

启动线程

package org.test;
class Test extends Thread{
    private String name;
    public Test(String name){
        this.name=name;
    }
    public void run(){
        for(int i=1;i<=5;i++) {
            System.out.println(name+i);
        }
    }
}
public class Hello {
    public static void main(String[] args) {
        Test a1=new Test("a");
        Test a2=new Test("b");
        a1.start();
        a2.start();
    }
}

实现Runnable接口

public interface Runnable{
	public void run();
}

语法：

class 类名称 implements Runnable{
	属性...;
	方法...;
	public void run(){
		线程主体;
	}
}

package org.test;

class Test implements Runnable{
    private String name;
    public Test(String name){
        this.name=name;
    }
    public void run(){
        for(int i=1;i<=5;i++){
            System.out.println(name+i);
        }
    }
}
public class Hello {
    public static void main(String[] args) {
        Test a1 = new Test("A");
        Test a2 = new Test("B");
        Thread t1=new Thread(a1);
        Thread t2=new Thread(a2);
        t1.start();
        t2.start();
    }
}

区别

继承Thread类不能资源共享

实现Runnable接口可以资源共享

Callable接口实现多线程

接口定义格式：

public interface Callable<V>{
	public V call() throws Exception;
}

package org.test;
import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

class Test implements Callable<String>{
    public String call() throws Exception{
        for(int i=1;i<=5;i++)
        {
            System.out.println(i);
        }
        return "0";
    }
}
public class Hello {
    public static void main(String[] args) throws Exception {
        Test a1=new Test();
        Test a2=new Test();
        FutureTask<String> t1 = new FutureTask<String>(a1);
        FutureTask<String> t2 = new FutureTask<String>(a2);
        new Thread(t1).start();
        new Thread(t2).start();
    }
}

将Callable接口的子类利用FutureTask类实现包装。由于FutureTask是Runnable接口的子类，所以可以利用Thread类的start()方法启动多线程。当线程执行完毕，可以利用Future接口中的get()方法返回线程的执行结果。

Java程序设计 多线程【一】

Java程序设计 多线程