JavaSE线程基础

 概述：

        1.程序(program)是为完成特定任务、用某种语言编写的一组指令的集合。即指一 段静态的代码。

        2.进程((process)就是正在执行的程序,从Windows角度讲，进程是操作系统进行 资源分配的最小单位。

        3.线程(thread)进程可进一步细化为线程，是一个进程内部的最小执行单元，是操 作系统进行任务调度的最小单元，隶属于进程。

线程与进程关系：

        1.一个进程可以包含多个线程，一个线程只能属于一个进程，线程不能脱离进程 而独立运行。

        2.每一个进程至少包含一个线程(称为主线程)；在主线程中开始执行程序， java程序的入口main()方法就是在主线程中被执行的。

        3.在主线程中可以创建并启动其它的线程；

        4.一个进程内的所有线程共享该进程的内存资源。

创建线程：

方式一：继承Thread类的方式

        在Java中要实现线程，最简单的方式就是扩展Thread类，重写其中的run方法。Thread类中的

run方法本身并不执行任何操作，如果我们重写了run方法，当线程启动时，它将执行 run方法。

public class MyThread extends Thread{
    @Override
    public void run() {
        for (int i=0;i<1000;i++){
            System.out.println("MyThread"+i);
        }
    }
}


public class Test {

    public static void main(String[] args) {

        //创建线程
        MyThread myThread = new MyThread();

        //启动线程
        myThread.start();

        for (int i=0;i<1000;i++){
            System.out.println("main结束"+i);
        }
    }
}

方式二：实现Runnable接口的方式

        java.lang.Runnable接口中仅仅只有一个抽象方法：public void run() {}。通过实现Runnable接口的方式来实现线程，只需要实现其中的run方法。Runnable接口的存在主要是为了解决Java中不允许多继承的问题。

public class ThreadDemo implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println("ThreadDemo" + i);
        }
    }
}



public class Test {

    public static void main(String[] args) {

        //创建线程执行任务
        ThreadDemo threadDemo = new ThreadDemo();

        //创建线程
        Thread t = new Thread(threadDemo);

        //启动线程
        t.start();

        for (int i = 0; i < 1000; i++) {
            System.out.println("main" + i);
        }
    }
}

继承方式与实现方式的区别：

区别：

        1.继承Thread: 线程代码存放Thread子类run方法中。

        2.实现Runnable：线程代码存在接口的子类的run方法。

实现Runnable的好处：

        1.避免了单继承的局限性。

        

        2.多个线程可以共享同一个接口实现类的对象，非常适合多个相同线程来处理同一份资源。

线程优先级：

        

概述：

        1.事实上，计算机只有一个CPU，各个线程轮流获得CPU的使用权，才能执行任务。

        

        2. 优先级较高的线程有更多获得CPU的机会。

       

        3.优先级用整数表示，取值范围是1~10，一般情况下，线程的默认优先级都是5，但是也可以

通过setPriority和getPriority方法来设置或返回优先级；

        

        //设置线程优先级
        t.setPriority(1);
        Thread.currentThread().setPriority(10);

        //返回线程优先级
        System.out.println(t.getPriority());
        System.out.println(Thread.currentThread().getPriority());

调度策略：

        1.时间片

        2.抢占式：高优先级线程抢占CPU

Java的调度方法：

        

        1.  同优先级线程组成先进先出队列，使用时间片策略。

        2.对高优先级，使用优先调度的抢占式策略。

线程让步：

        

public class ThreadDemo extends Thread {

    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            
            if (i%10==0){
                Thread.yield(); //线程让步
            }
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}

线程的状态：

        

        1.新建：当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态。

        

        2.就绪：处于新建状态的线程被start（）后，将进入线程队列等待CPU时间片，此时它已具备了运行的条件，只是没分配到CPU资源。

        3.运行：当就绪的线程被调度并获得CPU资源时，便进入运行状态，run（）方法定义了线程的操作和功能。

        

        4.阻塞：在某种特殊情况下，被人为挂起或执行输入输出操作时，让出CPU并临时中止自己的执行，进入阻塞状态。

        5.死亡：线程完成了它的全部工作或线程被提前强制性地中止或出现异常导致结束。

线程的分类：

Java中的线程分为两类：守护线程和用户线程

        

守护线程：

        1.任何一个守护线程都是整个JVM中所有非守护线程的保姆：

        2.只要当前JVM 实例中尚存在任何一个非守护线程没有结束，守护线程就全部工作。

        3.只有当最后一个非守护线程结束时，守护线程随着JVM 一同结束工作。

        4.守护线程的作用是为其他线程的运行提供便利服务，守护线程最典型的应用就是 GC (垃圾回收器 ) ，它就是一个很称职的守护者。

ThreadDemo1 t1 = new ThreadDemo1();
            //设置线程为守护线程，必须在启动前设置，其他用户线程结束后，守护线程自动结束
                    t1.setDaemon(true);
                    t1.start();

用户线程：

        

        用户线程和守护线程两者几乎没有区别，唯一的不同之处就在于虚拟机的离开：如果 用户线

程已经全部退出运行了，只剩下守护线程存在了，虚拟机也就退出了。 因为没 有了被守护者，守

护线程也就没有工作可做了，也就没有继续运行程序的必要了。

注意：设置线程为守护线程必须在启动线程之前，否则会出现IllegalThreadStateException异常。

多线程：

概述：

        多线程是指程序中包含多个执行单元，即在一个程序中可以同时运行多个不同的线程来执行

不同的任务，也就是说允许单个程序创建多个并行执行的线程来完成各自的任务。

用处：

        1.程序需要同时执行两个或多个任务。

        2.程序需要实现一些需要等待的任务时，如用户输入、文件读写操作、 网络操作、搜索等。

        3.需要一些后台运行的程序时。

优点：

        1.提高程序的响应。

        2.提高CPU的利用率。

        3.改善程序结构,将复杂任务分为对个线程,独立运行。

缺点：

        1.线程也是程序，所以线程需要占用内存，线程越多占用内存也越多。

        2.多线程需要协调和管理，所以需要CPU时间跟踪线程。

        3.线程之间对共享资源的访问会相互影响，必须解决竞用共享资源的问题。

线程同步：

概述：

        多线程同步：多个线程同时读写同一份共享资源时，可能会引起冲突。所以引入线程“同步”机制， 即各线程间要有先来后到。

同步：就是排队+锁

        1.几个线程之间要排队，一个个对共享资源进行操作，而不是同时进行操作。

        2. 为了保证数据在方法中被访问时的正确性，在访问时加入锁机制。

并发与并行：

        并发：在一个时间段内一次执行操作.例如卖票,抢购看似同时进行, 实际是一个一个执行。

        并行：多个CPU同时执行多个任务。比如：多个人同时做不同的事。

模拟买票：

synchronized关键字：

        确保一个时间点只有一个线程访问共享资源。可以给共享资源加一把锁，哪个线程获取了这把锁，才有权利访问该共享资源。

public class TicketThread_back extends Thread {

    //票数
    static int num = 10;
    static Object LockFlag = new Object();


    /*
         synchronized (锁对象) {
         同步代码
       }
       锁对象可以是任何对象，但是对于一个多线程必须是同一个
       在对象中，有一个对象头的区域，在对象头中有一个标志位(锁状态)
    */

    @Override
    public void run() {
        while (true) {
            synchronized (LockFlag) {
                if (num > 0) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + ":" + num);
                    num--;
                } else {
                    break;
                }
            }
        }
    }
}

synchronized修饰方法时：

public class TicketThread extends Thread {

    //票数
    static int num = 10;
    static Object LockFlag = new Object();

    @Override
    public void run() {
        while (true) {
            if (num<=0){
                break;
            }
            print();
        }
    }


    /*
         synchronized修饰方法时，没有显式的添加锁标志对象，在修饰非静态方法时，锁标志对象默认时this。
         在修饰静态方法时，锁标志对象是Class类的对象
    */
    public static synchronized void print(){
        if (num > 0) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + ":" + num);
            num--;
        }
    }

}

同步锁：

        同步锁可以是任何对象,必须唯一,保证多个线程获得是同一个对象(用来充当锁标记)。

同步执行过程：

        

        1.第一个线程访问，锁定同步对象，执行其中代码。

        2.第二个线程访问，发现同步对象被锁定，无法访问。

        3.第一个线程访问完毕，解锁同步对象。

        4.第二个线程访问，发现同步对象没有锁，然后锁定并访问。

注意：

        

        一个线程持有锁会导致其他所有需要此锁的线程挂起；在多线程竞争下， 加锁，释放锁会导

致比较多的上下文切换和调度延时，引起性能问题。

Lock锁：

概述：        

        

        1.从JDK 5.0开始，Java提供了更强大的线程同步机制-通过显式定义同步锁对象来实现同步。

同步锁使用Lock对象充当。

        2.java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了

对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获

得Lock对象。

        3.ReentrantLock类实现了Lock，它拥有与synchronized相同的并发性和内存语义，在实现线

程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁。

创建

ReentrantLock lock = new ReentrantLock(true);

调用

@Override
    public void run() {
        lock.lock();        //加锁，内部维护了一个锁的标志
        while (true){
            try {
                if (num>0){
                    System.out.println(Thread.currentThread().getName()+":"+num);
                    num--;
                }else {
                    break;
                }
            }finally {
                lock.unlock();    //释放锁
            }
        }
    }

synchronized和ReentrantLock区别：

synchronized：

        1.是关键字，底层实现是依赖编译后的指令实现。

        2.是一种隐式锁，自动添加，自动释放(执行任务完或出现异常)。

        3.主要用来修饰代码块和方法。

        

        4.需要靠对象头中的锁标志记录锁的状态。

        5.是非公平锁，等待锁时不需要排队，一旦释放，谁先抢到谁先执行。

 ReentrantLock：

        1.ReentrantLock是类，依赖代码控制。

        2.是一种显式锁，手动的添加，释放。

        3.只能修饰代码块。

        4.内部维护锁的状态标志。

        5.是公平锁，内部维护一个同步队列。

线程死锁：

概述：

        

        不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步 资源，

就形成了线程的死锁。

        出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续。

public class ThreadDemo extends Thread{


//模拟线程死锁
    static Object obja = new Object();
    static Object objb = new Object();
    boolean flag = true;

    public ThreadDemo(boolean flag) {
        this.flag = flag;
    }

    @Override
    public void run() {
//两个线程同时进入if 和 else  占用对方所需要的资源
        if (flag){
            synchronized (obja){
                System.out.println("if obja");
            }synchronized (objb){
                System.out.println("if objb");
            }
        }else {
            synchronized (objb){
                System.out.println("else objb");
            }synchronized (obja){
                System.out.println("else obja");
            }
        }
    }
}


public class Test {

    public static void main(String[] args) {
        ThreadDemo d1 = new ThreadDemo(true);
        ThreadDemo d2 = new ThreadDemo(false);
        d1.start();
        d2.start();
    }
}

解决方法：设计时考虑清楚锁的顺序，尽量减少嵌套的加锁交互数量。

线程通信：

概述：

        

         指的是多个线程通过相互牵制，相互调度，即线程间的相互作用。

方法:

        

        1..wait一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器。

       

         2..notify一旦执行此方法，就会唤醒被wait的一个线程。如果有多个线程被wait， 就唤醒优先

级高的那个。

        

        3..notifyAll一旦执行此方法，就会唤醒所有被wait的线程。

注意：.wait（），notify（），notifyAll（）三个方法必须使用在同步代码块或同步方法中。

案例：两线程交替打印1-100数字

public class PrintNumThread extends Thread{

    static int num = 0;
    static Object object = new Object();

    @Override
    public void run() {
        while (true){

            synchronized (object){
                //唤醒阻塞线程
                object.notify();
                if (num<=100){
                    System.out.println(Thread.currentThread().getName()+":"+num);
                    num++;
                }else {
                    break;
                }
                try {
                    //线程就进入阻塞状态，并释放同步监视器。
                    object.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}




public class Test {

    public static void main(String[] args) {
        PrintNumThread p1 = new PrintNumThread();
        PrintNumThread p2 = new PrintNumThread();
        p1.start();
        p2.start();
    }
}

新增线程创建方式

Callable接口：

        实现Callable接口与使用Runnable相比，Callable功能更强大些。

        1.相比run（）方法，可以有返回值。

        2.方法可以抛出异常。

        3.支持泛型的返回值。

        4.需要借助FutureTask类，获取返回结果。

接收任务创建线程：

        FutureTask<Integer> futureTask = new FutureTask(任务);

        Integer val = futureTask.get();获得线程call方法的返回值

SumThread sumThread = new SumThread();

        FutureTask<Integer> futureTask = new FutureTask(sumThread);

        Thread t = new Thread(futureTask);
               t.start();

               //获得线程call方法的返回值
        Integer sum = futureTask.get();
        System.out.println(sum);