java 线程

线程集锦

线程的几种的方式 继承Thread 类 ，实现Runable接口

Thread：

    1.  多个线程数据共享,因为Thread也实现Runnable接口
    2. java 单继承，不易扩展
    3. 以卖票实例

  public class TicketThread extends Thread{
    private int ticket = 10;
    public void run(){
        for(int i =0;i<10;i++){
            synchronized (this){
                if(this.ticket>0){
                    try {
                        Thread.sleep(100);
                        System.out.println(Thread.currentThread().getName()+"卖票---->"+(this.ticket--));
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }

    public static void main(String[] arg){
        TicketThread t1 = new TicketThread();
        new Thread(t1,"线程1").start();
        new Thread(t1,"线程2").start();
        //也达到了资源共享的目的，此处网上有各种写法，很多写法都是自圆其说，举一些特殊例子来印证自己的观点，然而事实却不尽如此。
    }
}

Runnable：

    1. 可以继承多个类和是实现多个接口
    2. 多个线程数据共享
    3. 以卖票实例

  public class TicketThread extends Thread{
    private int ticket = 10;
    public void run(){
        for(int i =0;i<10;i++){
            synchronized (this){
                if(this.ticket>0){
                    try {
                        Thread.sleep(100);
                        System.out.println(Thread.currentThread().getName()+"卖票---->"+(this.ticket--));
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }

    public static void main(String[] arg){
        TicketThread t1 = new TicketThread();
        new Thread(t1,"线程1").start();
        new Thread(t1,"线程2").start();
        //也达到了资源共享的目的，此处网上有各种写法，很多写法都是自圆其说，举一些特殊例子来印证自己的观点，然而事实却不尽如此。
    }
}

线程分--》 用户线程和守护线程

 用户线程即运行在前台的线程，而守护线程是运行在后台的线程。 守护线程作用是为其他前台线程的运行提供便利服务，而且仅在普通、非守护线程仍然运行时才需要，比如垃圾回收线程就是一个守护线程。当VM检测仅剩一个守护线程，而用户线程都已经退出运行时，VM就会退出，因为没有如果没有了被守护这，也就没有继续运行程序的必要了。如果有非守护线程仍然存活，VM就不会退出。
守护线程并非只有虚拟机内部提供，用户在编写程序时也可以自己设置守护线程。用户可以用Thread的setDaemon（true）方法设置当前线程为守护线程。

另外有几点需要注意：

1.setDaemon(true)必须在调用线程的start（）方法之前设置，否则会跑出IllegalThreadStateException异常。
2.在守护线程中产生的新线程也是守护线程。      
3. 不要认为所有的应用都可以分配给守护线程来进行服务，比如读写操作或者计算逻辑。

线程状态图

线程的生命周期.jpg

线程间的通信 :

• join 可以指定线程运行的顺序，线程的方法
• sleep线程休眠,当并不释放锁，线程的方法
• yield
• [wait()-->释放对象锁 ,notify()-->随机唤醒一个等待对象的锁,notifyall()--->唤醒所有等待锁得对象,都是对象的方法，并且需要在同步代码块中使用synchronized {}]
• 消费者与生产者模式

package com.threadPa;

import java.util.LinkedList;
import java.util.Random;

/**
 * Created by bright on 2019/7/15.
 */
public class PC {
    private static final int BUFF_SIZE = 10;
    private static final int CONSUMER_COUNT = 5;

    public static void main(String[] args) {
        LinkedList buffList = new LinkedList();
        Producer producer = new Producer(buffList);
        Consumer consumer = new Consumer(buffList);
        for (int i = 0; i < CONSUMER_COUNT; i++) {
            new Thread(consumer).start();
        }
        new Thread(producer).start();
    }

    static class Producer implements Runnable {
        private LinkedList list = null;

        public Producer(LinkedList list) {
            this.list = list;
        }

        @Override
        public void run() {
            while (true) {
                synchronized (list) {
                    while (list.size() > BUFF_SIZE) {// 用if判断是个坑
                        try {
                            System.out.println("Producer:"
                                    + Thread.currentThread().getId() + "wait");
                            list.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    Random random = new Random();
                    int i = random.nextInt();
                    System.out.println("Producer:"
                            + Thread.currentThread().getId() + "增加了内容为" + i
                            + "的节点");
                    list.add(i);
                    list.notifyAll();
                }
                try {
                    Thread.sleep(200);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    static class Consumer implements Runnable {
        private LinkedList list = null;

        public Consumer(LinkedList list) {
            this.list = list;
        }

        @Override
        public void run() {
            while (true) {
                synchronized (list) {
                    while (list.isEmpty()) {// 用if判断是个坑
                        System.out.println("Consumer"
                                + Thread.currentThread().getId() + "wait");
                        try {
                            list.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    System.out.println("Consumer:"
                            + Thread.currentThread().getId() + "移除了内容为"
                            + list.remove() + "的节点");
                    list.notifyAll();
                }
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

volatile：

volatile什么时候使用