Java---多线程02_串口i++; if(i%20==0)-CSDN博客

本文链接：https://blog.csdn.net/m0_37428263/article/details/93201216

1.礼让yield

yield暂停线程，使得当前执行的线程由运行状态直接转入就绪状态，然后交由cpu重新调度

package cn.MulThread.java.mhz;
/**
 * 礼让yield
 * yield暂停线程
 * @author MHZ
 *	礼让线程，让当前正在执行的线程暂停，不是阻塞状态，而是将线程从运行状态直接转入就绪状态,让cpu重新调度,公平竞争，注意是直接进入就绪状态不是阻塞状态，和sleep不同
 */
public class MyYieldJava {
	public static void main(String[] args)
	{
		new Thread(()->{
			for(int i=0;i<100;i++)
			{
				System.out.println("lambda.."+i);
			}
		}
		).start();
		
		for(int i=0;i<100;i++)
		{
			if(i%20==0) {
				Thread.yield();			//main线程进行礼让，让cpu重新调度
			}
			System.out.println("main.."+i);
		}
	}
}

2.join插队线程

join为合并线程(插队线程)，等待此线程执行结束后才可以执行其他线程，其他线程出于阻塞状态

同时要注意join属于成员方法，因此在使用之前需要先实例化一个对象，通过对象来调用join方法

package cn.MulThread.java.mhz;
/**
 * join为合并线程(插队线程)，等待此线程执行结束后才可以执行其他线程，其他线程出于阻塞状态
 * join为成员方法，必须通过实例化的对象来调用
 * @author MHZ
 *
 */
public class MyJoinJavaMulThread {
	public static void main(String[] args) throws InterruptedException
	{
		Thread t = new Thread(()->{
			for(int i=0;i<100;i++)
				System.out.println("lambda..."+i);
		});
		t.start();
		for(int i=0;i<50;i++)
		{
			if(i==20) {
				t.join();					//main线程被阻塞,t线程插队
			}
			System.out.println("main.."+i);
		}
	}
}

package cn.MulThread.java.mhz;

/**
 * join插队线程
 * @author MHZ
 *
 */

public class MyJoinJavaMulThread02 {
	public static void main(String[] args)
	{
		new Thread(new Father()).start();
	}
}

class Father implements Runnable{

	@Override
	public void run() {
		// TODO Auto-generated method stub
		System.out.println("想喝酒，儿子去买酒");
		try {
			Thread son = new Thread(new Son());
			son.start();
			son.join();					//father被阻塞
			System.out.println("喝到酒");
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
			System.out.println("儿子走丢了");
		}
	}
}

class Son implements Runnable{

	@Override
	public void run() {
		// TODO Auto-generated method stub
		System.out.println("儿子买酒途中");
	}
	
}

3.线程生命周期总览

注意：线程一旦到达死亡状态，不能再次切回到新生状态

package cn.MulThread.java.mhz;

import java.lang.Thread.State;

/**
 * 线程全部总结,由于就绪和运行状态并不能够由人来控制，所以两个状态返回的值都为RUNNABLE
 *  注意死亡状态不能再次切回到新生状态
 * @author MHZ
 *
 */
public class MyMulThreadJavaAllState {
	public static void main(String[] args) throws InterruptedException
	{
		Thread t = new Thread(()->{
			for(int i=0;i<10;i++)
			{
				if(i==5) {
					try {
						Thread.sleep(1000);				//阻塞
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}       
				}
				System.out.println("........");
			}
			
		});
		//观察线程的整个生命周期
		State state = t.getState();
		System.out.println(state);				//NEW 新生状态，返回枚举类型
		 
		t.start();
		state = t.getState();
		System.out.println(state);
		int num = Thread.activeCount();
		System.out.println(num);				//输出为2，表示当前有两个活动的线程
		while(state!=Thread.State.TERMINATED)				//当线程状态不等与死亡状态时
		{
			state = t.getState();
			Thread.sleep(100);
			System.out.println(state);
		}
	}
}

4.线程优先级

注意：优先级高的线程被优先执行的可能性变大，但是要注意这只是概率问题，并不是绝对的一个顺序

package cn.MulThread.java.mhz;
/**
 * 	多线程优先级
 * 	
 *  Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度器按照线程的优先级决定应该调度哪个线程来执行,优先级高的线程被优先执行的可能性比较大
 * 	 当然也是概率问题,优先级不代表绝对的先后顺序
 * 	提供了3个常量：MAX_PRIORITY   10
 *             MIN_PRIORITY   1
 *             NORM_PRIORITY  5(默认是5)
 * @author MHZ
 *
 */
public class MyMulThreadPriority {
	
	public static void main(String[] args)
	{
		
		System.out.println(Thread.MAX_PRIORITY);
		System.out.println(Thread.MIN_PRIORITY);
		System.out.println(Thread.NORM_PRIORITY);
		System.out.println(Thread.currentThread().getPriority());
		MyPriority mp = new MyPriority();
		
		Thread t1 = new Thread(mp,"mhz");			//为线程指定名字
		Thread t2 = new Thread(mp,"yxk");
		Thread t3 = new Thread(mp,"wzl");
		Thread t4 = new Thread(mp,"yzj");
		Thread t5 = new Thread(mp,"ysl");
		
		//设置优先级一定要在启动之前				设置的优先级不能越过[1,10]
		t1.setPriority(Thread.MAX_PRIORITY);
		t2.setPriority(Thread.MAX_PRIORITY);
		t3.setPriority(Thread.MAX_PRIORITY);
		t4.setPriority(Thread.MIN_PRIORITY);
		t5.setPriority(Thread.MIN_PRIORITY);
		
		t1.start();
		t2.start();
		t3.start();
		t4.start();
		t5.start();
		
	}
	
}

class MyPriority implements Runnable{

	@Override
	public void run() {
		// TODO Auto-generated method stub
		System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());
		Thread.yield();				//有运行状态重回就绪状态         礼让yield
	}
	
}

5.守护线程和用户线程

线程分为用户线程和守护线程，守护线程是为用户线程服务的，所以虚拟机不需要等待守护线程执行结束，但是要保证用户线程执行完毕

package cn.MulThread.java.mhz;
/**
 * 线程分为用户线程和守护线程，守护线程是为用户线程服务的，所以虚拟机不需要等待守护线程执行结束，但是要保证用户线程执行完毕
 * 默认情况下    都是用户线程
 * @author MHZ
 *
 */
public class MyJavaDeamonTest {
	public static void main(String[] args)
	{
		God god = new God();
		You1 you = new You1();
		
		
		Thread t1 = new Thread(you);
		t1.start();
		
		//设置守护进程
	    Thread t = new Thread(god);
	    t.setDaemon(true);
	    t.start();					//设置god为守护线程，jvm不需要等待守护线程执行完毕
	    
	}
}

//用户线程
class You1 implements Runnable{
	@Override
	public void run()
	{
		for(int i=1;i<=365*100;i++)
		{
			System.out.println("happy life...");
		}
		System.out.println("You game over...");
	}
}

//守护线程
class God implements Runnable{
	@Override
	public void run()
	{
		for(int i=1;i<=365*100000;i++)
		{
			System.out.println("God bless you...");
		}
		System.out.println("God game over...");
	}
}

6.多线程的其他方法

setName(),getName():指向线程的代理名字如果是真实角色的名字需要通过面向对象的方法来实现

Thread.currentThread():指向当前线程

isAlive():判断线程是否还活着

package cn.MulThread.java.mhz;
/**
 * 多线程其他方法
 * isAlive():判断线程是否还活着
 * Thread.currentThread():指向当前线程
 * setName(),getName():指向线程的代理名字				如果是真实角色的名字需要通过面向对象的方法来实现
 * @author MHZ
 *
 */
public class JavaMulThreadOtherMethod {
	public static void main(String[] args) throws InterruptedException
	{
		System.out.println(Thread.currentThread().isAlive());
		//设置名称：真实角色+代理角色
		MyInfo info = new MyInfo("真实对象");
		Thread t = new Thread(info);
		t.setName("代理对象");
		t.start();
		//isAlive判断线程是否活着
		t.sleep(1000);
		System.out.println(t.isAlive());
		System.out.println(t.currentThread().isAlive());			//t.currentThread()指向main
	}
}

class MyInfo implements Runnable{
	private String name;
	public MyInfo(String name)
	{
		this.name = name;
	}
	
	@Override
	public void run() {
		// TODO Auto-generated method stub
		System.out.println(Thread.currentThread().getName()+"-->"+this.name);
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	} 
}

7.线程安全：等待队列+锁机制

当同一个对象同时被多个线程访问的时候就会造成线程不安全，比如说火车购票中多个购买者同时访问，可能会出现同一张票被几个人买到的情况，这样线程不安全，我们希望能够做到线程同步，这时我们需要使用synchronized锁机制，一般有两种：同步方法和同步块

package cn.MulThread.java.mhz;

import java.util.ArrayList;
import java.util.List;

/**
 * 	线程同步
 *  Synchronized并发控制，解决线程不安全
 *  	分为两个用法：Synchronized方法和Synchronized 块                       同步块目标更明确，同步方法锁的是this
 *  	Synchronized范围太大可能影响性能
 *  	锁机制的两个难点：1.效率  2.安全
 * @author MHZ
 *
 */
public class MySynchronizedThread {
	public static void main(String[] args) throws InterruptedException {
		List<String> l = new ArrayList<String>();
		for(int i=0;i<10000;i++)
		{
			new Thread(()->{
				//同步块目标更明确
				synchronized(l){
					l.add(Thread.currentThread().getName());
				}
			}).start();
		}
		Thread.sleep(5000);
		System.out.println(l.size());
	}
}

8.线程安全: 实现一个模拟电影院抢票的多线程，每个顾客选择几个想坐的位置，影院提供了可选项，程序自动判断是否出票成功，注意其中doublechecking的运用，可以提高锁机制的效率

package cn.MulThread.java.mhz;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

/**
 * 模拟影院抢票过程，使用synchorized锁机制 synchorized锁机制有两种：同步方法和同步块，为了提高性能我们一般使用同步块
 * 
 * @author MHZ
 *
 */
public class HappyCinmaSynchronized {
	public static void main(String[] args) {
		List<Integer> list = new ArrayList<>();
		for(int i=1;i<=10;i++)
		{
			list.add(i);
		}
		List<Integer> list1= new ArrayList<>();
		list1.add(1);
		list1.add(2);
		list1.add(3);
		List<Integer> list2 = new ArrayList<>();
		list2.add(3);
		list2.add(4);
		list2.add(5);
		List<Integer> list3 = new ArrayList<>();
		list3.add(8);
		list3.add(9);
		list3.add(10);
		Cinma cinma = new Cinma(list, "mhz cinma",list.size());
		new Thread(new Customer(cinma, list1), "wzl").start();
		new Thread(new Customer(cinma, list2), "yxk").start();
		new Thread(new Customer(cinma, list3), "yzj").start();
	}
}

//影院
class Cinma {
	List<Integer> available; // 可用位置
	String name; 			// 名称
	int NoUsedSeats;		//未被占用的位置个数

	public Cinma(List<Integer> available, String name , int NoUsedSeats) {
		super();
		this.available = available;
		this.name = name;
		this.NoUsedSeats = NoUsedSeats;
	}

	// 购票
	public boolean bookTickets(List<Integer> list) {
		int seats = list.size();
		if (this.NoUsedSeats < seats) {
			return false;
		}
		for(int i=0;i<list.size();i++)
		{
			if(!available.contains(list.get(i))) return false;
		}
		System.out.println(available.toString());
		System.out.println("可用位置个数为:" + this.NoUsedSeats);
		
		this.NoUsedSeats -= seats;
		for(int i=0;i<seats;i++)
		{
			available.remove(list.get(i));
		}
		return true;
	}
}

//顾客
class Customer implements Runnable {
	Cinma cinma;
	List<Integer> seats;

	public Customer(Cinma cinma, List<Integer> seats) {
		super();
		this.cinma = cinma;
		this.seats = seats;
	}

	@Override
	public void run() {
		// TODO Auto-generated method stub
		//双重检测，double checking
		if (cinma.available.size() <= 0) {
			System.out.println("出票失败     " + Thread.currentThread().getName());
			return;
		}
		//礼让yield
//		if(Thread.currentThread().getName()=="wzl") {
//			Thread.yield();
//		}
		synchronized(cinma){
			if(cinma.available.size()<=0) {
				System.out.println("出票失败     " + Thread.currentThread().getName());
				return;
			}
			boolean flag = cinma.bookTickets(seats);
			if (flag) {
				System.out.println("出票成功     " + Thread.currentThread().getName() + "-->" + this.toString());
			} else {
				System.out.println("出票失败     " + Thread.currentThread().getName());
			}
		}
	}
	public String toString()
	{
		StringBuilder str = new StringBuilder();
		str.delete(0, str.length());
		for(int i=0;i<seats.size();i++)
		{
			if(seats.get(i)==null) break;
			str.append(seats.get(i)+" ");
		}
		str.append('\n');
		return str.toString();
	}
}

9.import java.util.concurrent.CopyOnWriteArrayList;

CopyOnWriteArrayList容器自带线程同步，不需要自己实现

package cn.MulThread.java.mhz;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;
/**
 * 容器内部自动实现了锁机制
 * 线程安全:操作并发容器
 * @author MHZ
 *
 */
public class SynContainer {
	public static void main(String[] args) throws InterruptedException {
		
		
		//使用CopyOnWriteArrayList
		CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();
		for(int i=0;i<10000;i++)
		{
			new Thread(() -> {
					list.add(Thread.currentThread().getName());
			}).start();
		}
		Thread.sleep(1000);
		System.out.println(list.size());
		
	
		//自己实现锁机制
		List<String> list1 = new ArrayList<String>();
		for(int i=0;i<10000;i++)
		{
			new Thread(()->{
				synchronized(list1) {
					list1.add(Thread.currentThread().getName());
				}
			}).start();
		}
		Thread.sleep(5000);
		System.out.println(list1.size());
	}
}