java多线程

进程

程序: 是为了完成特定任务,用某种语言编写的一组指令的集合,即指一段静态的代码

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

线程

线程是比进程更小的执行单位，线程是进程内部单一的一个顺序控制流。

多线程

多线程，指的是一个进程内的多个任务并发执行；

线程之间回进行cpu资源的抢占。

多线程的实现

三种形式：

1.继承Thread类，

2.实现Runnable接口(推荐)

3.实现Callable接口

继承Thread类

创建类继承Thread

public class Mythread extends Thread{

    public Mythread(String name) {
        super(name);
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"我是一个线程");
    }
 
}

 测试类

public class Test01 {
    public static void main(String[] args) {
        Mythread t1 = new Mythread("t1");
        t1.start();
    }
}

实现Runnable接口

public class MyRunnable implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"我是一个线程");
    }
}

测试类 

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

        MyRunnable myRunnable = new MyRunnable();

        Thread t1 = new Thread(myRunnable, "t1");
        Thread t2 = new Thread(myRunnable, "t2");

        t1.start();
        t2.start();
    }
}

 实现Callable接口

import java.util.concurrent.Callable;

public class Mycallable implements Callable {
    @Override
    public Object call() throws Exception {
        //线程睡眠
        Thread.sleep(300);
        System.out.println(Thread.currentThread().getName()+"ok");
        return "sss";
    }
}

测试类

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

public class Test03 {
    public static void main(String[] args) {
        Mycallable mycallable = new Mycallable();

        FutureTask task = new FutureTask(mycallable);

        Thread t1 = new Thread(task, "t1");
        Thread t2 = new Thread(task, "t2");
        t1.start();
        t2.start();
        try {
            System.out.println(task.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        System.out.println("main");

    }
}

 之所以推荐使用Runnable类是因为它可以继承其他类，而继承Thread类的方法就不能再继承其他类了（java是单继承）。Callable接口有很多的方法，但是实现太多复杂。

线程状态

五个状态： 新建状态 new

就绪状态 start 还没有抢占到cpu资源

运行状态 抢占到cpu资源了，执行run方法

阻塞状态 sleep，wait，没获取到锁等因素，线程暂停

死亡状态 正常死亡（run执行完毕）