线程学习总结1

什么是线程

线程

如何声明一个线程

一共有三种方法：

• 继承Thread类
• 实现Runnable接口
  严格意义上讲，通过实现Runnable接口声明的类不是一个线程类，实现该接口的类的作用是封装线程执行的业务逻辑
• 实现Callable来声明

对第三种方法的例子

  public class MyCallableThread implements Callable<String>{

    @Override
    public String call() throws Exception {

        System.out.println("MyCallableThread body .......");

        Thread.sleep(3000);

        System.out.println("MyCallableThread return....");

        return "CHINA";
    }

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

        Callable<String> target=new MyCallableThread();

        FutureTask<String> task=new FutureTask<>(target);

        new Thread(task).start();

        try {
            //1、调用FutureTask实例的get()方法可以获取Callable线程返回的结果
            //2、get()方法是一个阻塞的方法，即在这里会阻塞主线程
            System.out.println("tast return value:"+task.get(5, TimeUnit.SECONDS));
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        } catch (TimeoutException e) {
            e.printStackTrace();
        }

        System.out.println("+++++++++++++++++++++++++++++++++++++");
    }
}

如何启动线程

• 为什么通过start而不是run来启动线程
  start是启动一个新的线程，而run是在main主线程执行，但是线程的入口在run方法，start可以调用run方法。
• 线程的生命周期：
  1.新建状态：new
  2.就绪状态：start
  3.执行状态：占用cpu资源或者说该线程被cpu调度
  4.阻塞状态：sleep（），yeild（）从执行状态切换到就绪状态，join（）进入阻塞，导致启动此线程的线程阻塞。
  5.死亡状态：

public class FirstThread extends Thread{

    @Override
    public void run() {

        System.out.println("=================FirstThread  Begin=================");

        /*try {
            //当在一个线程中调用sleep函数的时候，当前线程将从执行状态进入阻塞状态
            //当阻塞状态结束过后，该线程从阻塞状态切换到就绪状态
            //处于就绪状态的线程等待被CPU调度,如果被CPU调度，那么线程又进入执行状态
            //因此，3s过后线程不一定立即进入执行状态
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //3s+*/     

        for(int i=0;i<100;i++){
            System.out.println("FirstThread *** "+i);
            if(i%10==0){
                //当i的值是10的倍数的时候，就把执行权限让渡出来
                /**
                 * 注意：仅仅是让渡执行权限，而不是把执行权限让给其他线程。
                 * 因为当当前线程把执行权限让渡出去过后，当前线程由执行状态切换到就绪状态
                 * 处于就绪状态的线程是可以被CPU调度的，也就是说，当前线程把执行权限让渡出来
                 * 接下来CPU依然可能继续调用该线程
                 * */
                System.out.println("FirstThread让渡了执行权限....");
                Thread.yield();
            }
        }

        System.out.println("=================FirstThread  End=================");

    }

}

一个例子

public class HusbandThread extends Thread{

    private WifeThread wife;

    public HusbandThread(WifeThread wife) {
        this.wife=wife;
    }

    @Override
    public void run() {
        System.out.println("老公开始做饭.....");

        System.out.println("老公没有盐，让老婆去买盐....");

        wife.start();

        try {
            //wife的join会导致启动wife的线程进入阻塞状态，一直要等到wife线程执行结束过后
            //当前线程才继续执行
            wife.join(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("老公继续做饭.....");

    }

}
public class WifeThread extends Thread{

    @Override
    public void run() {
        System.out.println("老婆开始去买盐......");

        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("老婆盐买回来了....");
    }

}

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

        new HusbandThread(new WifeThread()).start();

    }
}