Thread

start方法

start()用来启动一个线程，当调用start方法后，系统才会开启一个新的线程来执行用户定义的子任务，在这个过程中，会为相应的线程分配需要的资源。

run方法

　　run()方法是不需要用户来调用的，当通过start方法启动一个线程之后，当线程获得了CPU执行时间，便进入run方法体去执行具体的任务。注意，继承Thread类必须重写run方法，在run方法中定义具体要执行的任务。

sleep方法

　　sleep方法有两个重载版本：

sleep(long millis)     //参数为毫秒

sleep(long millis,int nanoseconds)    //第一参数为毫秒，第二个参数为纳秒123

sleep相当于让线程睡眠，交出CPU，让CPU去执行其他的任务。

写个多线程康康：

package com.company.tread;

public class Dome1 extends Thread{
    @Override
    public void run(){
        for (int i = 0; i < 10;i++){
            System.out.println(Thread.currentThread().getName()+"-----"+i);
            //线程睡眠
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    public static void main(String[] args) {
        //创建线程
        Dome1 t1 = new Dome1();
        Dome1 t2 = new Dome1();
        //开始线程
        t1.start();
        t2.start();
    }
}

这里可以看出线程是交替运行的，线程的调度是机器自动来进行。

Runnable

Runnable与Thread的区别：

Runnable 是接口；
Thread 是类，且实现了Runnable接口。
在使用Runnable定义的子类中没有start()方法，只有Thread类中才有。
Runnable接口是一个功能接口，并且具有单一的run()不接受任何参数，并且不返回任何值的方法。

在程序开发中多线程主要以实现Runnable接口为主。

Java多线程实现Runnable方式的具体方法步骤：

定义实现Runnable接口
覆盖Runnable接口中的run方法，将线程要运行的代码存放在run方法中。
通过Thread类建立线程对象。
将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数。
调用Thread类的start方法开启线程并调用Runnable接口子类run方法。

package com.company.tread;
//创建runnbale接口的实现类对象
public class Test implements Runnable{
    //覆写run方法
    @Override
    public void run() {
        for (int i = 0; i <=10; i++) {
            System.out.println(Thread.currentThread().getName()+"--->"+i);
        }
    }
    public static void main(String[] args) {
        //创建runnbale接口的实现类对象
        Test t1 = new Test();
        Test t2 = new Test();
        Test t3 = new Test();
        //创建线程对象，通过线程对象来开户我们的线程，代理
        new Thread(t1).start();
        new Thread(t2).start();
        new Thread(t3).start();
    }

}

Callable

Callable规定的方法是call()，而Runnable规定的方法是run()。
Callable的任务执行后可返回值，而Runnable的任务是不能返回值的。
call()方法可抛出异常，而run()方法是不能抛出异常的。
运行Callable任务可拿到一个Future对象。

package com.company.tread;

import java.util.concurrent.*;
import static java.util.concurrent.Executors.newFixedThreadPool;
public class Test1 implements Callable <Boolean>{
    //这里覆写的方法是call
    @Override
    public Boolean call() {
            for (int i = 0; i <=10; i++) {
                System.out.println(Thread.currentThread().getName()+"--->"+i);
            }
        return null;
    }
public static void main(String[] args) throws ExecutionException, InterruptedException {
    // 定义3个Callable类型的任务
        Test1 t1 =new Test1();
        Test1 t2 =new Test1();
        Test1 t3 =new Test1();
        //创建执行服务
        ExecutorService ser = newFixedThreadPool(3);
        //提交执行
        Future<Boolean> r1 = ser.submit(t1);
        Future<Boolean> r2 = ser.submit(t2);
        Future<Boolean> r3 = ser.submit(t3);
        //获取结果
        //关闭服务
        ser.shutdown();
    }
}

Java多线程笔记