java多线程

参考：java多线程与并发（基础篇）

附：https://www.cnblogs.com/zsql/p/11144688.html

　　https://www.cnblogs.com/wxd0108/p/5479442.html

Java多线程：彻底搞懂线程池：https://blog.csdn.net/u013541140/article/details/95225769

 

package org.java;

import java.util.Random;
/*
 Java多线程：
 多线程：指同时存在几个执行体，按几条不同的执行线索共同工作的情况
         实际上并不是同时，而是Java快速的控制一个线程切换到另一个线程
 单线程：一个程序（一个进程）从头到尾 只有一条执行线索


进程与线程
进程：是系统进行资源分配和调度的基本单位。
线程：一个进程中至少有一个线程，进程中的多个线程共享进程的 资源。
        系统是把资源分给进程，但是CPU很特殊，是被分配到线程的
            所以线程是CPU分配的基本单位。
一个进程中有多个线程，多个线程共享进程的堆和方法区资源
    但是每个线程有自己的程序计数器和栈区域。
程序计数器：是一块内存区域，用来记录线程当前要执行的指令地址 。
栈：用于存储该线程的局部变量，这些局部变量是该线程私有的，除此之外还用来存放线程的调用栈祯。
堆：是一个进程中最大的一块内存，堆是被进程中的所有线程共享的。
方法区：则用来存放 NM 加载的类、常量及静态变量等信息，也是线程共享的 。

 
进程：有独立的地址空间，一个进程崩溃后，在保护模式下不会对其它进程产生影响。
线程：是一个进程中的不同执行路径。线程有自己的堆栈和局部变量，
        但线程之间没有单独的地址空间，一个线程死掉就等于整个进程死掉。




并行与并发：
并行：多个cpu真正地处理一段逻辑，真正的同时处理
并发：只是cpu调度，看上取是同时执行，但实际上并不是

线程安全：
一段代码：在并发情况下，经过多线程，线程的调度顺序，不影响结果-->此时多线程 安全
一段代码：在并发情况下，经过多线程，线程的调度顺序，影响结果-->此时多线程 不安全    

        
同步：Java中的同步是通过人为的控制保证->保证共享资源的多线程 称为 安全线程
        使用关键字synchronized 

线程状态：
调用join()和sleep()方法，sleep()时间结束或被打断，join()中断,IO完成都会回到Runnable状态，等待JVM的调度。
调用wait()，使该线程处于等待池(wait blocked pool),直到notify()/notifyAll()，线程被唤醒被放到锁定池(lock blocked pool )，释放同步锁使线程回到可运行状态（Runnable）
对Running状态的线程加同步锁(Synchronized)使其进入(lock blocked pool ),同步锁被释放进入可运行状态(Runnable)。
此外，在runnable状态的线程是处于被调度的线程，此时的调度顺序是不一定的。Thread类中的yield方法可以让一个running状态的线程转入runnable。

monitor：
Java中的每个对象都有一个监视器，来监测并发代码的重入。
    在synchronized 范围内，监视器发挥作用。
        在非多线程编码时该监视器不发挥作用

wait/notify必须存在于synchronized块中。
     这三个关键字针对的是同一个监视器（某对象的监视器）
当某代码并不持有监视器的使用权时去wait或notify
    在synchronized块中去调用另一个对象的wait/notify（因为不同对象的监视器不同）
        都会抛出java.lang.IllegalMonitorStateException。

synchronized单独使用：
代码块：synchronized (this) {....}
直接用于方法： public synchronized void run() {...}


volatile
多线程的内存模型：main memory（主存）、working memory（线程栈）
    在处理数据时，线程会把值从主存load到本地栈，完成操作后再save回去
        (volatile关键词的作用：每次针对该变量的操作都激发一次load and save)    

多线程使用的变量如果不是volatile或者final修饰的，
    很有可能产生不可预知的结果
        另一个线程修改了这个值，但是之后在某线程看到的是修改之前的值
多线程是会缓存值的，线程栈 中可能有多个副本,数据可能出错
    本质上，volatile就是不去缓存，直接取值
        在线程安全的情况下加volatile会牺牲性能。

Java 内存模型规定，将所有的变量都存放在主内存中，当线程使用变量时，
    会把主内存里面的变量复制到自己的工作空间或者叫作工作内存，
        线程读写变量时操作的是自己工作内存中的变量 

共享变量的内存不可见问题，也就是线程B写入的值对线程A不可见。        
synchronized 的内存语义：
这个内存语义就可以解决共享变量内存可见性问题。
    进入synchronized块的内存语义 :是把在synchronized块内使用到的变量从线程的工作内存中清除，
        这样在synchronized块内使用到该变量时就不会从线程的工作内存中获取，而是直接从主内存中获取。
    退出synchronized块的内存语义:是把在synchronized块内对共享变量的修改刷新到主内存。
        会造成上下文切换的开销，独占锁，降低并发性
Volatile（[ˈvɒlətaɪl] 不稳定的）的理解：
该关键字可以确保对一个变量的更新对其他线程马上可见。
    当一个变量被声明为volatile时，线程在写入变量时不会把值缓存在寄存器或者其他地方，而是会把值刷新回主内存。
        当其他线程读取该共享变量时－，会从主内存重新获取最新值，而不是使用当前线程的工作内存中的值。
volatile的内存语义和synchronized有相似之处
当线程写入了volatile变量值时就等价于线程退出synchronized同步块（把写入工作内存的变量值同步到主内存），
读取volatile变量值时就相当于进入同步块（先清空本地内存变量值，再从主内存获取最新值）。不能保证原子性




基本线程类：Thread类，Runnable接口，Callable接口
Thread类：实现了Runnable接口，启动一个线程的方法：
        Thread thread=new Thread();
        thread.start();
重写run方法：
使用继承方式的好处是，在run（）方法内获取当前线程直接使用this就可以了，
    无须使用Thread.currentThread（）方法；
        不好的地方是Java不支持多继承，如果继承了Thread类，那么就不能再继承其他类。
            任务与代码没有分离，当多个线程执行一样的任务时需要多份任务代码。



public static Thread.yield();//当前线程可转让cpu控制权，让别的就绪状态线程运行（切换）
public static Thread.sleep();//暂停一段时间
public join();//在一个线程中调用other.join(),将等待other执行完后才继续本线程。　　　　
public interrupte();//后两个函数皆可以被打断
（中断标识值是否为true）
中断是一个状态！interrupt()方法只是将这个状态置为true而已
中断只会影响到wait状态、sleep状态和join状态。
    被打断的线程会抛出InterruptedException。
Thread.interrupted()检查当前线程是否发生中断，返回boolean
    synchronized在获锁的过程中是不能被中断的。

设置线程名称 Thread.name，并设置线程组 ThreadGroup，目的是方便管理
不能用try,catch来获取线程中的异常

Runnable
实现Runable接口
实现run方法：解决继承Thread的缺点，没有返回值

Callable
future模式：并发模式的一种，可以有两种形式，即无阻塞和阻塞
    分别是isDone和get。
        其中Future对象用来存放该线程的返回值以及状态

ExecutorService e = Executors.newFixedThreadPool(3);
 //submit方法有多重参数版本，及支持callable也能够支持runnable接口类型.
Future future = e.submit(new myCallable());
future.isDone() //return true,false 无阻塞
future.get() // return 返回值，阻塞直到该线程运行结束



 */
public class SaleTicket implements Runnable {

    public int total;
    public int count;

    public SaleTicket() {
        total = 100;
        count = 0;
    }
    
    public void run() {
        while (total > 0) {
            synchronized (this) {//ˈsɪŋkrənaɪzd]
                if (total > 0) {
                    try {//Thread.sleep(800);
                        Thread.sleep(new Random().nextInt(1000));
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    count++;
                    total--;
                    System.out.println(Thread.currentThread().getName() + "	当前票号：" + count);
                }
            }
        }
    }
    
    //第二种方法
//    private static int num = 0;
//
//    public static synchronized int sale() {
//        int i = ++num;
//        return i > 100 ? -1 : i; // 如果i>100返回-1.小于100返回i
//    }
//    @Override
//    public void run() {
//        int i = 0;
//        //System.out.println(SaleTicket.num);
//        while ((i = SaleTicket.sale()) != -1) {
//            System.out.println("第"+Thread.currentThread().getName() + "号窗口售卖第" + i+"张票");
//            try {
//                Thread.sleep(100);
//            } catch (InterruptedException e) {
//                e.printStackTrace();
//            }
//
//        }
//    }
}

package org.java;

public class ThreadTest {

    public static void main(String[] args) {
        SaleTicket st = new SaleTicket();
        //线程 实现了runnable接口，可以当作参数 传入thread，同时定义线程名字
        // 也可一块初始化 名字//Thread thread=new Thread(saleTicket, "1");
        for (int i = 1; i <= 5; i++) {
            new Thread(st, "售票点" + i).start();
        }
    }
}