15、线程

 一、线程（Thread）——进程（process）

　　线程是程序类的控制流，线程和进程非常相似。

　　多进程：在操作系统能同时运行多个任务（程序、软件）

　　多线程：在同一个应用程序中有多个顺序流任务同时执行。

二、Thread类和Runnable接口

　　Thread实现了Runnable接口

　　在A1类下继承Thread类，重写run方法之后的单线程串行运行：

public class A {
    public static void main(String[] args) {
        new A1().run();
        new A1().run();
    }
}
class A1 extends Thread{
    @Override
    public void run() {
        for(int i=0;i<100;i++){
            System.out.println(i);
        }
    }
}

多线程方法：

1、使用Thread类下的start()方法可以实现简单的多线程（创建两个对象），Thread.currentThread（）指当前线程：sleep()方法可以使当前线程睡眠指定毫秒数后唤醒。

public class A {
    public static void main(String[] args) {
        A1 a1=new A1();
        a1.setName("A");
        a1.start();
        A1 a2=new A1();
        a2.setName("B");
        a2.start();
    }
}
class A1 extends Thread{
    @Override
    public void run() {
        for(int i=0;i<1000;i++){
            try {
                sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+i);
        }
    }
}

2、使用Runnable接口，向Thread构造器传入实现了Runnable接口的对象：

public class A {
    public static void main(String[] args) {
       A2 a1=new A2();
       Thread t1=new Thread(a1);
       t1.setName("A");//如果不设置名字，将按照JDK给定的Thread1和Thread2来命名
       t1.start();

        A2 a2=new A2();
        Thread t2=new Thread(a2);
        t2.setName("B");
        t2.start();
    }
}

class A2 implements Runnable{
    @Override
    public void run() {
        for(int i=0;i<100;i++){
            System.out.println(Thread.currentThread().getName()+i);
        }
    }
}

3、也可以使用匿名内部类：（即用即调）

public class B {
    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    System.out.println(Thread.currentThread().getName() + i);
                }
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    System.out.println(Thread.currentThread().getName() + i);
                }
            }
        }).start();
    }
}

4、使用FutureTask类，因为FutureTask类实现了Runnable接口，所以，间接地实现了Runnable接口。使用回调式接口，可以返回值。

　　FutureTask类实现Runnable接口，而FutureTask构造器中需要的是Callable接口对应的对象，所以创建Callable接口对应的对象，传递给FutrueTask，创建一个FutrueTask对象，然后将这个实现了Runnable接口的对象传给Thread类的构造器，实现线程创建。

public class C {
    public static void main(String[] args) {
        C1 c1=new C1();
        FutureTask<Integer> task=new FutureTask(c1);
        Thread t=new Thread(task);
        t.start();
        try {
            System.out.println("总计是"+task.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

        C1 c2=new C1();
        FutureTask<Integer> task2=new FutureTask(c2);
        Thread t2=new Thread(task2);
        t2.start();
        try {
            System.out.println("总计是"+task.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

class C1 implements Callable<Integer>{
    @Override
    public Integer call() throws Exception {
        int sum=0;
        for(int i=0;i<=100;i++){
            sum+=i;
        }
        return sum;
    }
}

注意：1、start方法不要重复使用，一旦线程start，必须执行完或中止才会执行下一个start

　　　2、stop方法可以使线程急刹车。

三、三种基本创建线程的区别

　　--、使用Runable接口

　　　　可以将线程代码和线程数据分开，形成清晰的模型。

　　　　可以继承其他类。

　　--、直接继承Thread类

　　　　不能再从其他类继承；

　　　　编写简单，可以直接操纵线程。

　　1、使用Callable接口规定的方法是call()，而Runnable规定的方法是run()。

　　2、Callable的任务执行后可返回值，而Runnable的任务是不能返回值的。

　　3、call()方法可抛出异常，而run()方法是不能抛出异常的。

　　4、运行Callable任务可拿到一个Future对象，Future表示异步计算的结果。

　　　　它提供了检查计算时候完成的方法，以等待计算的完成，并检索计算的结果。

　　　　通过Future对象可了解任务执行情况，可取消任务的执行，还可获取任务执行的结果。

　　　　Thread类构造器中填入的是Runnable接口实现类对象；FutureTask类构造器中填入的是Callable接口实现类对象。而FutureTask类实现了Runnable接口，这样就可以间接地使用Thread构造器调用FutureTask类的对象创建线程了。

　　　　

　　四、线程池创建线程

　　通过Executor来启动线程比用Thread的start()要好。在新特性中，可以很容易控制线程的启动、执行和关闭过程，还可以很容易使用线程池的特性。

　　1）、减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务。

　　2）、可以根据系统的承受能力，调整线程池中工作线程的数目，防止因为消耗过多的内存，而把服务器累趴下（每个线程需要大约1MB内存，线程开越多，消耗的内存越大，最后死机）

　　Executors下的方法：newFixedThreadPool方法是创建n个线程的线程池

　　　　　　　　　　　　newSingleThreadExecutor方法是创建单个线程

　　　　　　　　　　　　newCacheThreadPool()方法是缓存线程池，以最快速度创建线程池，不管创建多少内存。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
/**
 * Created by Administrator on 2018/2/10 0010.
 */
public class D {
    public static void main(String[] args) {
        ExecutorService service= Executors.newFixedThreadPool(8);
        for(int i=0;i<100;i++){
            service.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName()+":"+"启动线程");
                }
            });
        }
        service.shutdown();
        try {
            service.awaitTermination(Long.MAX_VALUE, TimeUnit.DAYS);
            System.out.println("线程结束");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }
}

未来式、Callable接口、线程池混合编写多线程

线程池下的两个方法：

submit方法形参是callable回调式接口对象，返回未来式（下面的例子）

execute方法的形参是Runnable接口对象（上面的例子）

import java.util.concurrent.*;
/**
 * Created by Administrator on 2018/2/10 0010.
 */
public class E {
    public static void main(String[] args) {
        ExecutorService service= Executors.newFixedThreadPool(10);
        for(int i=0;i<20;i++){
           Future<String> futrue= service.submit(new E1(i));
            try {
                System.out.println(futrue.get());
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
        }
        service.shutdown();
        try {
            service.awaitTermination(Long.MAX_VALUE, TimeUnit.DAYS);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("结束");
    }
}
class E1 implements Callable<String>{
    public E1(){}
    private int id;
    public E1(int i){
        this.id=i;
    }
    @Override
    public String call() throws Exception {
        return  Thread.currentThread().getName()+"你好"+id;
    }
}

五、线程状态

　　　　　　　　　　　　　　　　　　　　状态图

　　线程可以一直执行下去，直到下面的某件事情发生才停止。

　　-明确地从目标run()方法返回，run方法结束。

　　-遇到一个无法捕获的运行时异常。

　　-调用了不推荐使用的stop()、Interrupt()方法。

　　如果上面事情都没发生，run()方法就会一直运行下去，甚至在创建他的程序结束之后，线程还会一直运行。

　　线程优先级设立：

　　Runnable下对象使用setPriority方法，其中包含三个等级的默认优先级：MAX(10）、NORMAL、MIN（1）

　　可以通过yield()方法明确地让出当前线程的控制权，通过完成他的目标方法或调用stop()方法终止线程。

 

六、join线程

　　join线程：Thread提供了让一个线程等待另一个线程完成的方法：join()方法，当在某个程序执行流中调用其他线程的join()方法时，调用线程将被阻塞，直到join方法加入的join线程完成为止。

　　该线程可以实现将一个大问题划分为若干小线程逐击破的想法。程序可以由三个线程组成：主线程、新线程、join线程，开始时候主线程和新线程交叉允许，当主线程的循环变量i等于20时，启动了join线程，该线程不会和主线交叉运行，而主线程必须等到该线程结束后才可以向下执行，但是由于没有控制新线程，所以新线程将还和join线程一同并发执行，而仅仅是主线程处于等待状态。

package com.zxc.Q;

/**
 * Created by Administrator on 2018/2/10 0010.
 */
public class G {
    public static void main(String[] args) {
        G1 g1=new G1();
        g1.setName("G1:");
        g1.start();
    }
}
class G1 extends Thread{
    public void run() {
        for(int i=0;i<200;i++){
            if(i==50){
                G2 g2=new G2();
                g2.setName("G2:");
                g2.start();
                try {
                    g2.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println(Thread.currentThread().getName()+i);
        }
    }
}
class G2 extends Thread{
    public void run() {
        for(int i=0;i<200;i++){
            System.out.println(Thread.currentThread().getName()+i);
        }
    }
}

七、守护线程

　　在多数情况下，实际上先创建的是一个能够在应用程序中做一些简单的、周期性任务的后台线程。可以调用setDaemon()方法标记一个线程是守护线程。

　　下面的例子是h1对象为守护线程，守护h2,h3线程。

public class H {
    public static void main(String[] args) {
        H1 h1=new H1();
        h1.setName("H1");
        h1.setDaemon(true);
        h1.start();

        H2 h2=new H2();
        h2.setName("H2");
        h2.start();

        H2 h3=new H2();
        h3.setName("H3");
        h3.start();
    }
}

class H1 extends Thread{
    @Override
    public void run() {
        for(int i=0;i<1000;i++){
            try {
                sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}
class H2 extends Thread{
    @Override
    public void run() {
        for(int i=0;i<100;i++){
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}

七、总结方法

　　Runnable  Thread  start stop interrupt   sleep  join   

　　Executorservice   Exectors  submit   Callable  executor  shutdown

　　awaitTermination

　　newFixedThreadPool  newSingleThreadPool   newCacheThreadPool   FutureTask Future

　　yield  setPriority  notify notifyall  wait

　　中断异常的三个：wait sleep interrupt

八、Sychronized同步（效率低）

银行取钱问题：******用Sychronized来锁定方法并不安全，最好用来锁定对象线程。

//Account账户类
public class Account
{
    private String accountNo;
    private double balance;


    public Account(){}

    public Account(String accountNo , double balance)
    {
        this.accountNo = accountNo;
        this.balance = balance;
    }

    public void setAccountNo(String accountNo)
    {
        this.accountNo = accountNo;
    }
    public String getAccountNo()
    {
        return this.accountNo;
    }

    public void setBalance(double balance)
    {
        this.balance = balance;
    }
    public double getBalance()
    {
        return this.balance;
    }
}

//DrawAccount 存款类
public class DrawAccount extends Thread{
    private Account account;
    private  double drawAmount;
    public DrawAccount(String name,Account account,double drawAmount){
        super(name);
        this.account=account;
        this.drawAmount=drawAmount;
    }

    @Override
    public void run() {
        synchronized (this.account) {   //给this.account上锁
            if (account.getBalance() >= drawAmount) {
                account.setBalance(account.getBalance() - this.drawAmount);
                System.out.println(this.getName() + "取了" + this.drawAmount + "你的余额是：" + account.getBalance());
            } else {
                System.out.println("余额不足");
            }
        }
    }
}


//TestDraw测试类
public class TestDraw {
    public static void main(String[] args) {
        Account acct=new Account("NO123456789",800);
        new DrawAccount("甲",acct,800).start();
        new DrawAccount("乙",acct,800).start();
    }
}

九、synchronized和volatile和Lock区别

　　　　volatile关键字：保证内存的可见性

　　　　　　　　　　　　在每次访问变量时都会进行一次刷新，因此每次访问都是主内存中最新版本。所以volatile作用之一是保证变量修改的实时可见性。

　　　　　　　　　　　并不保证原子性

　　　　　　　　　　　防止指令重排

　　sychronized比volatile更安全，而后者比前者效率高，后者是轻量级的同步机制，前者为重量级的同步机制。有了sychronized就不需要用voaltile了。前者可以保证原子性和可见性，而后者不能保障原子性，从而就不能保证完全锁定。用volatile修饰的变量不能再更改：count++、count+=1等都不能；

　　论锁定功效:Lock>sychronized>volatile

　　Lock：

lock和Synchronized的区别：