Java学习笔记17----多线程（二）

1.线程的状态：
新建：线程被创建出来
就绪：线程具有执行资格，没有执行权。
运行：线程具有执行资格，具有执行权。
阻塞：线程不具有执行资格，也不具有执行权。
死亡：线程不具有执行资格，也不具有执行权，线程死亡了，等待回收。
2.线程池
为什么要出现线程池：
线程是CPU执行的基本单位，我们每次开启一个线程是很浪费资源的。而线程池是一个可以帮我们预先创建线程对象的地方，创建好放在池子中，等有任务需要执行了，我们就可以让线程池中的线程去执行，任务执行完线程池中的线程还可以回收，下次还可以用来执行任务。
(1)线程池：是一个容器，装有线程对象的容器，可以帮我们管理线程对象；
线程池可以预先帮助我们创建一些数量的线程对象，放在池子中，等人为需要执行了，就可以让线程去执行任务，执行完了，可以回收 。
(2)线程池原理：
如何获取线程池：JDK1.5之前需要我们自己去动手实现，1.5之后java给我们内置好了线程池，直接使用即可。
线程池工厂：Executors工厂类来生产线程池。
(3)Executors工厂类生产线程的方法：
public static ExecutorService newCachedThreadPool();根据任务的数量来创建线程的个数。
public static ExecutorService newFixedThreadPool(int nThread);固定初始化几个线程
public static ExecutorService newSingleThreadExector();初始化一个线程的线程池；单线程工作，一次只能执行一个任务。
以上的方法返回的都是ExecutorService对象，该对象表示一个线程池，可以执行Runnable或者Callable对象代表的线程。
Callable 接口类似于 Runnable，两者都是为那些其实例可能被另一个线程执行的类设计的。但是 Runnable 不会返回结果，并且无法抛出经过检查的异常。
Callable 这个任务接口,执行完之后会有返回值 跟线程池配合使用,Callable中要重写call方法。
Runnable 这个任务接口 执行完之后没有返回值
使用步骤： (1).创建线程池对象；(2).创建Runnable实例；(3).提交Runable实例;(4).关闭线程池shutdown()方法。
(4)ExecutorService中的方法：
Future<?>submit(Runnable task);提交一个Runnable任务用于执行。并返回一个表示该任务的Future。
Futuresubmit(Runnable task,T result);提交一个Runnable任务用于执行。并返回一个表示该任务的Future。
Futuresubmit(Callabletask);提交一个返回值的任务用于执行，返回一个表示任务的未决结果的Future。
接口Future表示异步计算的结果，它提供了检查计算是否完成的方法，以等待计算的完成。计算完成后只能使用get方法获取结果。
代码如下：

public class MyRunnable implements Runnable{
    @Override
    public void run() {

        System.out.println(Thread.currentThread().getName()+"-----"+"任务执行了");
    }
}

import java.util.concurrent.Callable;

public class MyCallable implements Callable<String> {
    @Override
    public String call() {
        String s="程序执行了";
        System.out.println(Thread.currentThread().getName()+"----"+s);
        return s;
    }
}

public class MyRunnableTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //创建一个单线程对象的线程池
        ExecutorService service = Executors.newSingleThreadExecutor();
        //提交Runnable实例
        MyRunnable myRunnable = new MyRunnable();
        Future submit=service.submit(myRunnable );
        System.out.println(submit.get());//没有返回值null
        Future<Integer> submit1=service.submit(new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                int sum=0;
               for(int i=1;i<=100;i++){
                   sum+=i;
               }
               return sum;
            }
        });
        System.out.println(submit1.get());//返回值5050
     service.shutdown();
    }
}


public class MyRunnableTest2 {
    public static void main(String[] args) {
        //根据任务的数量创建线程
        ExecutorService service= Executors.newCachedThreadPool();
        MyRunnable myRunnable = new MyRunnable();
        Future submit=service.submit(myRunnable);
        Future submit1=service.submit(myRunnable);
        Future submit2=service.submit(myRunnable);
        Future submit3=service.submit(myRunnable);
        service.shutdown();
    }
}

public class MyCallableTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //定义有三个线程的线程池
        ExecutorService service= Executors.newFixedThreadPool(3);
        MyCallable myCallable=new MyCallable();
       Future<String> submit=service.submit(myCallable);
        Future<String> submit1=service.submit(myCallable);
        Future<String> submit2=service.submit(myCallable);
        System.out.println(submit.get());
        System.out.println(submit1.get());
        System.out.println(submit2.get());
        service.shutdown();//关闭线程池
    }
}

3.用匿名内部类开起线程。
匿名内部类：本质相当于一个对象，是实现了该接口或继承了该抽象类的子类对象。
匿名内部类的方式实现多线程程序：new Thread(){代码…}.start();
New Thread(new Runable(){代码…}).start();
代码如下：

public class MyTest {
    public static void main(String[] args) {
        new Thread(new Thread(){
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"程序执行了");
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("匿名内部类开启线程");
            }
        }).start();
    }
} 

4．定时器：一个工具类，在指定的时间或日期执行任务。
定时器是一个应用十分广泛的线程工具，可以用于调度多个定时任务以后台线程的方式运行。
可以通过Timer和TimerTask类来实现定义调度的功能。
(1)Timer一种工具，线程用其安排以后在后台线程中执行的任务，可以安排任务执行一次或者重复执行。
public Timer();默认的构造方法
public void schedule(TimerTask task, long delay);
延迟delay秒之后执行
public void schedule(TimerTask task, long delay, long period);
第一次延时delay秒之后执行，以后每间隔period执行。
public void schedule(TimerTask task, Date time);
在指定日期执行
public void schedule(TimerTask task, Date firstTime, long period)
在指定日期第一次执行，然后间隔period秒重复执行。
(2)TimerTask 定时任务
TimerTask()创建一个新的计时器任务。
public abstract void run()计时器任务要执行
public Boolean cancel()取消执行任务。
代码如下：

public class MyTimerTest1 {
    public static void main(String[] args) {
        Timer timer=new Timer();
        TimerTask timerTask=new MyTimerTask(timer);

      //  timer.schedule(timerTask,1000);//延迟1秒后执行任务
        timer.schedule(timerTask,2000,1000);//延迟2秒后执行，然后间1秒，重复执行
    }
}

public class MyTimerTest2 {
    public static void main(String[] args) throws ParseException {
        //在指定日期执行
        String str="2018-11-21 22:09:30";
        SimpleDateFormat simpleDateFormat=new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
        Date date=simpleDateFormat.parse(str);
        Timer timer=new Timer();
        MyTimerTask myTimerTask = new MyTimerTask(timer);
        timer.schedule(myTimerTask,date);
    }
}

//定时任务
public class MyTimerTask extends TimerTask {
    //定时器
    Timer timer;
    public MyTimerTask(Timer timer){
        this.timer=timer;
    }
    @Override
    public void run() {
        //System.out.println("定时任务执行了");
        //定时关机
        Runtime runtime=Runtime.getRuntime();
        try {
            runtime.exec("shutdown -s -t 0");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

案例：定时删除多级文件夹目录

public class Demo {
    public static void main(String[] args) {
        //定时删除指定的带内容的目录
        Timer timer=new Timer();
        MyTimerTask1 timerTask=new MyTimerTask1(timer);
       timer.schedule(timerTask,3000);
    }
}

public class MyTimerTask1 extends TimerTask {
    Timer timer;
    public MyTimerTask1(Timer timer){
        this.timer=timer;
    }

    @Override
    public void run() {
        File file=new File("D:\\course");
        deleteFile(file);
    }

    private void deleteFile(File file) {
        File[] files = file.listFiles();
        for (File f : files) {
            if (f.isFile()) {
                f.delete();
            }else{
                deleteFile(f);
            }
        }
        file.delete();
    }
}

5.（1）Java内存模型
Java 内存模型规定了所有变量都存储在主内存中，每一条线程还有自己的工作内存。线程的工作内存 中存储了被该线程所使用的变量(该变量是从主内存中拷贝过来的)。
线程对变量的操作（读取，赋值）都必须在内存中进行；但是不同线程之间是不能通信的，即无法访问对方工作内存中的变量，线程间变量值的传递均需要通过主内存来完成。
（2）Java中的可见性
在java中提供了Volatile关键字来保证可见性。
普通的共享变量不能保证可见性，因为普通变量被修改之后，什么时候把值写入到主内存是不确定的，所以当其他线程读取时，此时内存中有可能还是其他的旧值，因此无法保证可见性。
但是当volatile修饰之后的共享变量，它能保证被修改后的值会立即被更新的主内存，当有其他线程来读取时，读取到的就是新的值，所以保证了java 的可见性。

（3）Volatile关键字，当多个线程共享数据时，能够保证内存之间的可见性。相当于比synchronize较轻量级的同步策略。
但是注意Volatile不能保证原子性，不具备互斥性。
代码如下：

public class DemoTest {
    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();
        Thread thread = new Thread(myRunnable);
        thread.start();
       while(true){
           if(myRunnable.isB()){
               System.out.println("程序进来了，值修改成功");
               break;
           }
       }
    }
}
public class MyRunnable implements Runnable {
    private volatile boolean b=false;
    public void setB(boolean b){
        this.b=b;
    }
   public boolean isB(){
       return b;
   }
    @Override
    public void run() {
        //线程睡3秒
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        b=true;
        System.out.println("b的值更改了"+b);
    }
}

6.CAS算法
(1).什么是CAS算法：
CAS的是Compare and Swap的简称，即比较再交换。
Jdk5增加了并发包java.util.concurrent.*,其下面的类使用CAS算法实现了区别于synchronize同步锁的乐观锁。JDK5之前是依靠syncthronize关键字保证同步的，这是一种独占锁，也是悲观锁。
CAS是一种硬件对并发的支持，针对多处理器操作而设计的一种特殊指令，用于管理对共享数据的并发访问。
(2)CAS的算法过程描述：
CAS算法是一种无锁的算法，内存值V，旧的预期值A，要修改的新值B。当且仅当A与V相同时，将V值修改为新值B，否则什么都不做。
例子：

在上图中，线程1 与线程2同时抢时间片，假设线程1先抢到（注意：一个线程抢到另一个没抢到，则没抢到的那个线程并不挂起，下次继续参与抢。），先执行，线程1中就得预期值A是10，内存值V是10，两者一样，进行值修改加一，得到新值B为11，写入内存内存值V变为11，同时线程2的旧的预期值为10，和内存值V的值11不一样，则不进行任何操作。两个线程再次进行抢时间片，继续下轮执行。
（3）CAS算法在JDk中的应用
在原子类变量中，例如java.util.concurrent.atomic中的原子操作类AtomicXXX
都使用了这些底层的JVM支持为数字类型的引用类型提供了一种高效的CAS操作。
而在java.util.concurrent.中的大多数类在实现时都直接或者间接的使用了这些原子变量类。例如AtomicInteger类中的getAndIncrement方法
例子如下：

import java.util.concurrent.atomic.AtomicInteger;

public class MyRunnable2 implements Runnable {
    AtomicInteger i=new AtomicInteger();
    public int getI(){
        return i.getAndIncrement();
    }
    @Override
    public void run() {
        try {
            Thread.sleep(50);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(getI());

    }
}
public class MyRunnableTest2 {
    public static void main(String[] args) {
        Runnable myRunnable2=new MyRunnable2();
        while(true){
            Thread th=new Thread(myRunnable2);
            th.start();
        }
    }
}