线程——状态

线程状态图

线程停止——stop

/**
 * @author xiaomingstu
 * @date 2020-06-11 23:35
 * 建议线程正常停止---》利用次数，不建议死循环
 * 建议使用标识位---》设置一个标识位
 * 不要使用stop 或者destroy等过时或者JDK不建议使用的方法
 */
public class ThreadStop implements Runnable {

    //设置一个标识位
    private boolean flag = true;
    
    @Override
    public void run() {
        int i = 0;
        while (flag){
            System.out.println("run......Thread" + i++);
        }
    }

    //设置一个方法停止线程，转换标识位
    public void stop(){
        this.flag = false;
    }

    public static void main(String[] args) {
        ThreadStop threadStop = new ThreadStop();
        new Thread(threadStop).start();
        for (int i = 0; i < 1000; i++) {
            if(i == 900){
                threadStop.stop();
                System.out.println("—————————线程该停止了！—————————");
            }
        }
    }
}

线程休眠——sleep

/**
 * @author xiaomingstu
 * @date 2020-06-11 23:53
 * 在指定的毫秒数内让当前正在执行的线程休眠（暂停执行）；
 */
public class ThreadSleep {
    /**
     * 做一个简易倒计时,10秒钟,控制台每一秒输出一个数字,如10,9,8,7.....0
     */
    public static void main(String[] args) throws InterruptedException {
        for (int i = 10; i >= 0; i--) {
            Thread.sleep(1000);
            System.out.println(i);
        }
    }
}

线程礼让——yield

让当前执行的线程暂停，但不阻塞；
将线程从运行状态转为就绪状态；
让CPU重新调度，礼让不一定成功；

/**
 * @author xiaomingstu
 * @date 2020-06-16 21:58
 */
public class ThreadYield {

    public static void main(String[] args) {
        MyYield myYield = new MyYield();
        new Thread(myYield,"a").start();
        new Thread(myYield,"b").start();
    }
}


class MyYield implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "线程开始执行");
        Thread.yield();
        System.out.println(Thread.currentThread().getName() + "线程结束执行");
    }
}

线程强制执行——join

/**
 * @author xiaomingstu
 * @date 2020-06-16 22:25
 */
public class ThreadJoin implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println("线程vip" + i);
        }
    }


    public static void main(String[] args) throws InterruptedException{
        ThreadJoin join = new ThreadJoin();
        Thread thread = new Thread(join);
        thread.start();

        for (int i = 0; i < 400; i++) {
            if(i == 200){
                thread.join();
            }
            System.out.println("main" + i);
        }
    }

}

线程状态

	public static enum Thread.State
	extends Enum<Thread.State>

线程状态。
一个线程可以有以下规定： 
	NEW
	尚未启动的线程处于此状态。 
	RUNNABLE
	在Jave虚拟机中执行的线程处于此状态。 
	BLOCKED
	被阻塞等待监视器锁定的线程处于此状态。
	WAITING
	正在等待另一个线程执行特定动作的线程处于此状态。
	TIMED_WAITING
	正在等待另一个线程执行动作达到指定等待时间的线程处于此状态。 
	TERMINATED
	已退出的线程处于此状态。 
	
一个线程可以在给定时间点处于一个状态。这些状态是不反应任何操作系统线程状态的虚拟机状态。

线程优先级——priority

static int ---------MAX_PRIORITY
线程可以拥有的最大优先级。

static int ---------MIN_PRIORITY
线程可以拥有的最小优先级。

static int -------- NORM_PRIORITY
被分配给线程的默认优先级。

void setPriority(int newPriority)
更改此线程的优先级。

int getPriority()
返回此线程的优先级。

/**
 * @author xiaomingstu
 * @date 2020-06-16 22:55
 */

public class ThreadPriority {

    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName() + "---------->" + Thread.currentThread().getPriority());

        MyPriority myPriority = new MyPriority();

        Thread t1 = new Thread(myPriority);
        Thread t2 = new Thread(myPriority);
        Thread t3 = new Thread(myPriority);
        Thread t4 = new Thread(myPriority);
        Thread t5 = new Thread(myPriority);

        t1.start();

        t2.setPriority(1);
        t2.start();

        t3.setPriority(3);
        t3.start();

        t4.setPriority(5);
        t4.start();

        t5.setPriority(7);
        t5.start();

    }
}


class MyPriority implements Runnable{
    
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "---------->" + Thread.currentThread().getPriority());
    }
}

守护线程——daemon

• 线程分为用户线程和守护线程
• 虚拟机必须确保用户线程执行完毕
• 虚拟机不用等待守护线程执行完毕
• 如后台记录操作日志,监控内存,垃圾回收

/**
 * @author xiaomingstu
 * @date 2020-06-16 23:04
 */

public class ThreadDaemon {

    public static void main(String[] args) {
        God god = new God();
        You you = new You();
        Thread thread = new Thread(god);
        thread.setDaemon(true);

        thread.start();

        new Thread(you).start();
    }
}


class God implements Runnable{

    @Override
    public void run() {
        while (true){
            System.out.println("上帝保佑着你！ ");
        }
    }
}

class You implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 36500; i++) {
            System.out.println("活着。。。。。。。。。。。");
        }
        System.out.println("人生不过三万年！");
    }
}

线程同步

• 处理多线程问题时,多个线程访问同一个对象,并且某些线程还想修改这个对象,这时候我们就需要线程同步,线程同步其实是一种等待机制,多个需要同时访问此对象的线程进入这个对象的等待池形成队列,等待前面的线程使用完毕,下一个线程在使用
• 由于同一进程的多个线程共享同一块存储空间,在带来方便的同时,也带来了访问的冲突问题,为了保证数据在方法中被访问时的正确性,在访问时加入锁机制syncronized,当一个线程获得对象的排他锁,独占资源,其他线程必须等待,使用后释放锁即可,存在一下问题:
  • 一个线程持有锁会导致其他所有需要此锁的进程挂起
  • 在多线程竞争的情况下,加锁,释放锁会导致比较多的上下文切换和调度延时,引起性能问题
  • 如果一个优先级高的线程等待一个优先级低的线程释放锁会导致优先级倒置,引起性能问题

同步方法和同步块

• 同步块: synchronized(obj){}

• obj称之为同步监视器

  • obj可以是任何对象,但是推荐使用共享资源作为同步监视器
  • 同步方法中无需指定同步监视器,因为同步方法中的同步监视器就是this,就是这个对象本身,或者是class

• 同步监视器的执行过程

  • 第一个线程访问,锁定同步监视器,执行其中的代码
  • 第二个线程访问,发现同步监视器被锁定,无法访问
  • 第一个线程访问完毕,解锁同步监视器
  • 第二个线程访问,发现同步监视器没有锁,然后锁定并访问

• 同步方法在方法上添加synchronized关键子,锁的是对象本身

死锁

• 多个线程各自占有一些共享资源,并且互相等待其他线程占有的资源释放才能运行,而导致两个或者多个线程都在等待对方释放资源,都停止执行的情形,某一个同步块同时拥有"两个以上的对象锁"时,就可能发生死锁现象

死锁产生的条件

• 互斥条件: 一个资源每次只能被一个进程使用
• 请求保持条件: 一个进程因请求资源而阻塞时.对以获得的资源保持不放
• 不剥夺条件:进程已获得的资源,在未使用完之前,不能强行剥夺
• 循环等待条件: 若干进程之间形成一种头尾相接的循环等待资源关系

Lock锁

• 从JDK1.5开始,java提供了更为强大的线程同步机制——通过显示定义同步锁对象来实现同步,同步锁使用lock对象来充当

• java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问,每次只能有一个线程对Lock对象加锁,线程开始访问共享资源之前应先获得Lock对象

• ReentrantLock类实现了Lock,它拥有与synchronized相同的并发性和内存语义,在实现线程安全的控制中.比较常用的是ReentrantLock,可以显示加锁,释放锁

import org.apache.poi.ss.formula.functions.T;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @author xiaomingstu
 * @date 2020-06-18 21:32
 */
public class ThreadLock {

    public static void main(String[] args) {
        LockDemo lockDemo = new LockDemo();
        new Thread(lockDemo,"LockA").start();
        new Thread(lockDemo,"LockB").start();
        new Thread(lockDemo,"LockC").start();
    }
}

class LockDemo implements Runnable{

    int ticketNums = 10;

    //定义Lock锁
    private ReentrantLock reentrantLock = new ReentrantLock();

    @Override
    public void run() {

        while (true){
            reentrantLock.lock();
            try {
                if(ticketNums > 0){
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "购买了第" + ticketNums-- + "张票");
                }else {
                    break;
                }
            } finally {
                reentrantLock.unlock();
            }
        }
    }
}

和synchronized对比

• Lock是显示锁(手动开启和关闭,别忘记关闭锁) synchronized是隐式锁,出了作用域自动释放
• Lock只有代码块锁,synchronized有代码块锁和方法锁
• 使用lock锁,JVM将花费较少的时间来调度线程,性能更好,并且具有更好的扩展性(提供更多的子类)
• 优先使用顺序
  • Lock > 同步代码块 > 同步方法

线程协作

生产者和消费者问题

• 假设仓库中只能存放一件产品,生产者将生产出来的产品放入仓库,消费者将仓库产品取走消费
• 如果仓库中没有产品,则生产者将产品放入仓库,否则停止生产并等待,直到仓库中的产品被消费者取走为止
• 如果仓库中放有产品,则消费者可以将产品取走消费,否则停止消费并等待,直到仓库中再次放入产品为止这是一个线程同步问题,生产者和消费者共享一个资源,并且生产者和消费者之间相互依赖,互为条件
• 对于生产者,没有生产产品之前,要通知消费者等待,而生产了产品之后,又要马上通知消费者消费
• 对于消费者,在消费之后,要通知生产者已经结束消费,需要生产新的产品以供消费
• 在生产者消费者问题上,仅有synchronized是不够的
  • synchronized可阻止并发更新同一个共享资源,实现了同步
  • synchronized不能用来实现不同线程之间消息传递(通信)

java提供解决线程之间通信问题的方法：

解决方式

并发协作模式"生产者/消费者模式" ===>管程法

• 生产者: 负责生产数据的模块(可能是方法,对象,线程,数组)
• 消费者: 负责处理数据的模块(可能是方法,对象,线程,数组)
• 缓冲区:消费者不能直接使用生产者的数据,他们之间有个缓冲区 生产者将生产好的数据放入缓冲区,消费者从缓冲区拿出数据

/**
 * @author xiaomingstu
 * @date 2020-06-18 23:00
 */
public class SyncContainer {

    //设置容器大小
    Product[] products = new Product[10];
    //容器计数器
    int count = 0;


    //生产者放入产品
    public synchronized void push(Product product){
        //如果容器满了，就通知消费者消费
        //通知消费者消费，生产者等待
        if(count == products.length){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        products[count] = product;
        count++;
        //可以通知消费者消费
        this.notifyAll();
    }


    //消费者消费产品
    public synchronized Product pop() {
        //判断容器是否为空
        if(count == 0){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //消费
        count--;
        Product product = products[count];

        //通知生产者生产
        this.notifyAll();
        return product;
    }
}

/**
 * @author xiaomingstu
 * @date 2020-06-18 22:38
 */
public class Product {

    private int id;

    public Product(int id){
        this.id = id;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }
}

/**
 * @author xiaomingstu
 * @date 2020-06-18 23:24
 */
public class ProviderThread extends Thread {

    //创建好的缓冲区
    private SyncContainer syncContainer;

    public ProviderThread(SyncContainer syncContainer){
        this.syncContainer = syncContainer;
    }

    @Override
    public void run(){
        for (int i = 0; i < 100; i++) {
            System.out.println("生产了" + i +"只鸡！");
            syncContainer.push(new Product(i));
        }
    }

}

/**
 * @author xiaomingstu
 * @date 2020-06-18 22:50
 */
public class ConsumerThread extends Thread {

    private SyncContainer syncContainer;

    public ConsumerThread(SyncContainer syncContainer) {
        this.syncContainer = syncContainer;
    }

    @Override
    public void run(){
        for (int i = 0; i < 100; i++) {
            Product pop = syncContainer.pop();
            System.out.println("消费了第" + pop.getId() + "号产品！");
        }
    }
}

/**
 * @author xiaomingstu
 * @date 2020-06-18 23:28
 */
public class TestMain {

    public static void main(String[] args) {
        SyncContainer syncContainer = new SyncContainer();
        new ProviderThread(syncContainer).start();
        new ConsumerThread(syncContainer).start();
    }
}

并发协作模式"生产者/消费者模式" ===>信号灯法

//产品-->节目
public class TV {

   //演员表演,观众等待
   //观众观看,演员等待
   String voice;   //表演的节目
   boolean flag = true;

   //表演
   public synchronized void play(String voice) {

       if(!flag){
           try {
               this.wait();
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
       }

       System.out.println("演员表演了" + voice);
       //通知观众观看
       this.voice = voice;
       this.notifyAll();
       this.flag = !flag;

   }

   //观看
   public synchronized void watch(){
       if(flag){
           try {
               this.wait();
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
       }
       System.out.println("观众观看了" + voice);
       //通知演员表演
       this.notifyAll();
       this.flag = !flag;
   }
}

public class Player extends Thread {
   private TV tv = null;

   public Player(TV tv) {
       this.tv = tv;
   }

   @Override
   public void run() {
       for (int i = 0; i < 100; i++) {
           tv.play("表演了" + i + "号节目");
       }
   }
}

public class Watcher extends Thread {

   private TV tv = null;

   public Watcher(TV tv) {
       this.tv = tv;
   }

   @Override
   public void run() {
       for (int i = 0; i < 100; i++) {
           tv.watch();
       }
   }
}

//测试生产者消费者问题:信号灯法,标志位解决
public class Main {

   public static void main(String[] args) {
       TV tv = new TV();
       new Watcher(tv).start();
       new Player(tv).start();

   }
}