java-多线程

一、什么是多线程？

Java 给多线程编程提供了内置的支持。 一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。

多线程是多任务的一种特别的形式，但多线程使用了更小的资源开销。

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

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

二、一个线程的生命周期

新建状态:
使用 new 关键字和 Thread 类或其子类建立一个线程对象后，该线程对象就处于新建状态。它保持这个状态直到程序 start() 这个线程。

就绪状态:
当线程对象调用了start()方法之后，该线程就进入就绪状态。就绪状态的线程处于就绪队列中，要等待JVM里线程调度器的调度。

运行状态:
如果就绪状态的线程获取 CPU 资源，就可以执行 run()，此时线程便处于运行状态。处于运行状态的线程最为复杂，它可以变为阻塞状态、就绪状态和死亡状态。

阻塞状态:
如果一个线程执行了sleep（睡眠）、suspend（挂起）等方法，失去所占用资源之后，该线程就从运行状态进入阻塞状态。在睡眠时间已到或获得设备资源后可以重新进入就绪状态。可以分为三种：

等待阻塞：运行状态中的线程执行 wait() 方法，使线程进入到等待阻塞状态。

同步阻塞：线程在获取 synchronized 同步锁失败(因为同步锁被其他线程占用)。

其他阻塞：通过调用线程的 sleep() 或 join() 发出了 I/O 请求时，线程就会进入到阻塞状态。当sleep() 状态超时，join() 等待线程终止或超时，或者 I/O 处理完毕，线程重新转入就绪状态。

死亡状态:
一个运行状态的线程完成任务或者其他终止条件发生时，该线程就切换到终止状态。

三、多线程的三种实现方式

java 提供了三种创建线程的方法：

1、通过实现 Runnable 接口；

2、通过继承 Thread 类本身；

********继承Thread类可以直接操作线程，相比于实现Runnable接口的方法，比较适合于实现类的单继承的场景下。

3、通过 Callable 和 Future 创建线程。

实现Callable接口，重写call()方法
FutureTask ft= new FutureTask(Callable接口的实现类)；
Thread t = new Thread(ft);
t.start();
ft.get()//获取call()方法的返回值

四、线程的一些属性

线程同步
线程间通信
线程死锁
线程控制：挂起、停止和恢复

五、多线程的总结

有效利用多线程的关键是理解程序是并发执行而不是串行执行的。例如：程序中有两个子系统需要并发执行，这时候就需要利用多线程编程。

通过对多线程的使用，可以编写出非常高效的程序。不过请注意，如果你创建太多的线程，程序执行的效率实际上是降低了，而不是提升了。

请记住，上下文的切换开销也很重要，如果你创建了太多的线程，CPU 花费在上下文的切换的时间将多于执行程序的时间！

六、多线程的一些练习

代码实现

public class Test1 implements Runnable {
    @Override
    public void run() {
        Thread t = Thread.currentThread();
        for (int i = 0; i < 20; i++) {
            System.out.println("你好，来自线程"+t.getName());
        }
    }

    public static void main(String[] args) {
        Test1 t= new Test1();
        Thread t1= new Thread(t,"Thread-0");
        Thread t2= new Thread(t,"Thread-1");
        t1.start();
        t2.start();
    }
}

运行结果


代码实现

public class Test2 implements Runnable{
    @Override
    public void run() {
        int height= 1000;
        Thread t = Thread.currentThread();
        while(height>0){
            System.out.println(t.getName()+"爬完了100米！");
            if(t.getName().equals("年轻人")){
                try {
                    t.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }else{
                try {
                    t.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            height-=100;
            if(height==0){
                System.out.println(t.getName()+"爬完了！");
            }
        }
    }

    public static void main(String[] args) {
        Test2 t=new Test2();
        Thread t1=new Thread(t,"年轻人");
        Thread t2=new Thread(t,"老年人");
        t1.start();
        t2.start();
    }
}

实现效果


代码实现

public class Test3 {
    public static void main(String[] args) {
        Thread t = Thread.currentThread();
        Thread t1= new Thread();
        System.out.println("*****显示默认优先级******");
        System.out.println("主线程名:"+t.getName()+",优先级："+t.getPriority());
        System.out.println("子线程名："+t1.getName()+",优先级："+t1.getPriority());
        t.setPriority(10);
        t1.setPriority(1);
        System.out.println("*****修改默认优先级后******");
        System.out.println("主线程名:"+t.getName()+",优先级："+t.getPriority());
        System.out.println("子线程名："+t1.getName()+",优先级："+t1.getPriority());
    }
}

运行效果