Java中线程的相关知识整理

线程的概念

程序：program，是一个静态的概念

进程：progress，是一个动态的概念

进程是程序的一次动态执行过程，占用特定的地址空间

每个进程都是独立的，由3部分组成cpu,data,code

缺点：内存的浪费，cpu的负担

线程：Thread，是进程中一个“单一的连续控制流程”/执行路径

线程又被称为轻量级进程

一个进程可拥有多个并行的线程

一个进程中的线程共享相同的内存单元/内存地址空间->可以访问相同的变量和对象，而且它们从同一堆中分配对象->通信、数据交换、同步操作

由于线程间的通信是在同一地址空间上进行的，所以不需要额外的通信机制，这就使得通信更简便而且信息传递速度也更快。

线程和进程的区别

Java中实现多线程

在Java中负责线程的这个功能的是Java.lang.Thread这个类

可以同创建Thread的实例来创建新的线程

每个线程都是通过某个特定Thread对象所对应的方法run()来完成其操作的，方法run()称为线程体

通过调用Thread类的start()方法类启动一个线程体

继承Thread类方式的缺点：那就是如果我们的类已经从一个类继承，则无法再继承Thread类

/**
 * 模拟龟兔赛跑
 1、创建多线程  继承  Thread  +重写run(线程体)
 2、使用线程: 创建子类对象 + 调用对象.start()方法    线程启动
 * @author W.Sky
 *
 */
public class Rabbit extends Thread {
	
	@Override
	public void run() {
		//线程体
		for(int i=0;i<100;i++){
			System.out.println("兔子跑了"+i+"步");
		}
		
	}
	
}

class Tortoise extends Thread {

	@Override
	public void run() {
		//线程体
		for(int i=0;i<100;i++){
			System.out.println("乌龟跑了"+i+"步");
		}
		
	}
	
}

通过Runnable接口实现多线程

优点：可以同时实现继承，实现Runnable接口方式要通用一些

1)避免单继承

2)方便共享资源，同一份资源，多个代理访问

 

/**
 推荐  Runnable 创建线程
 1)、避免单继承的局限性
 2)、便于共享资源
  
  
  使用 Runnable 创建线程
  1、类 实现 Runnable接口 +重写 run()   -->真实角色类
  2、启动多线程  使用静态代理
    1)、创建真实角色
    2)、创建代理角色 +真实角色引用
    3)、调用 .start() 启动线程
  
  
 * @author W.Sky
 *
 */
public class Programmer implements Runnable {

	@Override
	public void run() {
		for(int i=0;i<1000;i++){
			System.out.println("一边敲helloworld....");
		}
	}


}

public class ProgrammerApp {

	
	public static void main(String[] args) {
		 //1)、创建真实角色
		Programmer pro =new Programmer();		
		  //2)、创建代理角色 +真实角色引用
		Thread proxy =new Thread(pro);
		  //3)、调用 .start() 启动线程
		proxy.start();
		
		for(int i=0;i<1000;i++){
			System.out.println("一边聊qq....");
		}
	}

}

通过Callable接口实现多线程

优点：可以获取返回值

缺点：繁琐

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
/**
 * 使用Callable创建线程
 * @author W.Sky
 *
 */
public class Call {
	public static void main(String[] args) throws InterruptedException, ExecutionException {
		//创建线程
		ExecutorService  ser=Executors.newFixedThreadPool(2);
		Race tortoise = new Race("老不死",1000);
		Race rabbit = new Race("小兔子",500);
		//获取值
		Future<Integer> result1 =ser.submit(tortoise) ;
		Future<Integer> result2 =ser.submit(rabbit) ;
		
		Thread.sleep(2000); //2秒
		tortoise.setFlag(false); //停止线程体循环
		rabbit.setFlag(false);
		
		int num1 =result1.get();
		int num2 =result2.get();
		System.out.println("乌龟跑了-->"+num1+"步");
		System.out.println("小兔子跑了-->"+num2+"步");
		//停止服务 
		ser.shutdownNow();

	}
}

class Race implements Callable<Integer>{
	private String name ; //名称
	private long time; //延时时间
	private boolean flag =true;
	private int step =0; //步
	public Race() {
	}	

	public Race(String name) {
		super();
		this.name = name;
	}
	public Race(String name,long time) {
		super();
		this.name = name;
		this.time =time;
	}

	@Override
	public Integer call() throws Exception {
		while(flag){
			Thread.sleep(time); //延时
			step++;
		}
		return step;
	}

	public String getName() {
		return name;
	}

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

	

	public long getTime() {
		return time;
	}

	public void setTime(long time) {
		this.time = time;
	}

	public boolean isFlag() {
		return flag;
	}

	public void setFlag(boolean flag) {
		this.flag = flag;
	}

	public int getStep() {
		return step;
	}

	public void setStep(int step) {
		this.step = step;
	}
	
}

线程的状态

新生状态、就绪状态、运行状态、阻塞状态、死亡状态

/**
 * join:合并线程
 * @author W.Sky
 *
 */
public class JoinDemo01 extends Thread {

	public static void main(String[] args) throws InterruptedException {
		JoinDemo01 demo = new JoinDemo01();
		Thread t = new Thread(demo); //新生
		t.start();//就绪
		//cpu调度 运行
		
		
		for(int i=0;i<1000;i++){
			if(50==i){
				t.join(); //main阻塞...
			}
			System.out.println("main...."+i);
		}
	}
	
	@Override
	public void run() {
		for(int i=0;i<1000;i++){
			System.out.println("join...."+i);
		}
	}

}

Sleep模拟网络延时 

/**
 * Sleep模拟 网络延时  线程不安全的类
 * @author W.Sky
 *
 */
public class SleepDemo02 {

	public static void main(String[] args) {
		//真实角色
		Web12306 web= new Web12306();
		Web12306 web2 = new Web12306();
		//代理
		Thread t1 =new Thread(web,"路人甲");
		Thread t2 =new Thread(web,"黄牛已");
		Thread t3 =new Thread(web,"攻城师");
		//启动线程
		t1.start();
		t2.start();
		t3.start();
	}

}

class Web12306 implements Runnable {
	private int num =50;

	@Override
	public void run() {
		while(true){
			if(num<=0){
				break; //跳出循环
			}
			try {
				Thread.sleep(500);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName()+"抢到了"+num--);
		}
	}
	
}

线程基本信息

优先级：表达的是概率，不是绝对的先后顺序

/**
 *
  Thread.currentThread()	 :当前线程
  setName():设置名称
  getName():获取名称
  isAlive():判断状态

 * @author W.Sky
 *
 */
public class InfoDemo01 {

	public static void main(String[] args) throws InterruptedException {
		MyThread it =new MyThread();
		Thread proxy =new Thread(it,"挨踢");
		proxy.setName("test");
		System.out.println(proxy.getName());
		System.out.println(Thread.currentThread().getName()); //main
		
		proxy.start();
		System.out.println("启动后的状态:"+proxy.isAlive());
		Thread.sleep(200);
		it.stop();
		Thread.sleep(100);
		System.out.println("停止后的状态:"+proxy.isAlive());
	}

}

 

/**
 * 优先级:概率，不是绝对的先后顺序
   MAX_PRIORITY  10
   NORM_PRIORITY 5 (默认)
   MIN_PRIORITY  1
   
   setPriority()
   getPriority()
 * @author W.Sky
 *
 */
public class InfoDemo02 {

	public static void main(String[] args) throws InterruptedException {
		MyThread it =new MyThread();
		Thread p1 =new Thread(it,"挨踢1");
		MyThread it2 =new MyThread();
		Thread p2 =new Thread(it2,"挨踢2");
		
		p1.setPriority(Thread.MIN_PRIORITY); //设置优先级
		p2.setPriority(Thread.MAX_PRIORITY);//设置优先级
		p1.start();
		p2.start();
		
		
		
		Thread.sleep(100);
		it.stop();
		it2.stop();
	}

}

线程同步

由于同一进程的多个线程共享同一片存储空间，在带来方便的同时，也带来了访问冲突这个严重的问题。Java语言提供了专门机制以解决这种冲突，有效避免了同一数据对象被多个线程同时访问。

由于我们可以通过private关键字来保证数据对象只能被方法访问，所以我们只需针对方法提出一套机制，这套机制就是synchronized关键字，它包括两种用法：synchronized方法和synchronized块。

/**
 * 过多的同步方法可能造成死锁
 * @author W.Sky
 *
 */
public class SynDemo03 {

	public static void main(String[] args) {
		Object g =new Object();
		Object m = new Object();
		Test t1 =new Test(g,m);
		Test2 t2 = new Test2(g,m);
		Thread proxy = new Thread(t1);
		Thread proxy2 = new Thread(t2);
		proxy.start();
		proxy2.start();
	}

}
class Test implements Runnable{
	Object goods ;
	Object money ;
	
	public Test(Object goods, Object money) {
		super();
		this.goods = goods;
		this.money = money;
	}

	@Override
	public void run() {
		while(true){
			test();
		}
	}
	
	public void test(){
		synchronized(goods){
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			synchronized(money){
				
			}
			
		}
		System.out.println("一手给钱");
	}
	

}

class Test2  implements Runnable{
	Object goods ;
	Object money ;
	public Test2(Object goods, Object money) {
		super();
		this.goods = goods;
		this.money = money;
	}

	@Override
	public void run() {
		while(true){
			test();
		}
	}
	
	public void test(){
		synchronized(money){
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			synchronized(goods){
				
			}
			
		}
		System.out.println("一手给货");
	}

	
}

生产者消费者模式

生产者消费者问题，也称有限缓冲问题，是一个多线程同步问题的经典案例。该问题描述了两个共享固定大小缓冲区的线程——即所谓的“生产者”和“消费者”——在实际运行时会发生的问题。生产者主要的作用是生成一定量的数据放到缓冲区中，然后重复此过程。与此同时，消费者也在缓冲区中消耗这些数据。该问题的关键就是要保证生产者不会在缓冲区满时加入数据，消费者也不会在缓冲区空时消耗数据。

要解决该问题，就必须让生产者在缓冲区满时休眠，等到下次消费者消耗缓冲区中数据的时候，生产者才能被唤醒，开始往缓冲区添加数据。同样，也可以让消费者在缓冲区空时进入休眠，等到生产者往缓冲区添加数据之后，再唤醒消费者。通常常用的方法有信号灯法、管程灯。如果解决方法不够完善，则容易出现死锁的情况。出现死锁时，两个线程都会陷入休眠，等待对方唤醒自己。

/**
 一个场景,共同的资源
  生产者消费者模式 信号灯法
 wait() :等待，释放锁   sleep 不释放锁
 notify()/notifyAll():唤醒
  与 synchronized
 * @author W.Sky
 *
 */
public class Movie {
	private String pic ;
	//信号灯
	//flag -->T 生产生产，消费者等待 ，生产完成后通知消费
	//flag -->F 消费者消费 生产者等待, 消费完成后通知生产
	private boolean flag =true;

	public synchronized void play(String pic){
		if(!flag){ //生产者等待
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		//开始生产
		try {
			Thread.sleep(500);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("生产了:"+pic);
		//生产完毕		
		this.pic =pic;
		//通知消费
		this.notify();
		//生产者停下
		this.flag =false;
	}
	
	public synchronized void watch(){
		if(flag){ //消费者等待
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		//开始消费
		try {
			Thread.sleep(200);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("消费了"+pic);
		//消费完毕
		//通知生产
		this.notifyAll();
		//消费停止
		this.flag=true;
	}
}

任务调度

Timer定时器类

TimerTask任务类

通过java timer timertask:(spring的任务调度就是通过他们来实现的)

在这种实现方式中，Timer类实现的是类似闹钟的功能，也就是定时或者每隔一段时间触发一次线程。其实Timer类本身就是一个线程，只是这个线程是用来实现调用其他线程的。而TimerTask类是一个抽象类，该类实现了Runnable接口，所以按照前面的介绍，该类具备多线程的能力。

在这种实现方式中，通过继承TimerTask使该类获得了线程的能力，将需要的多线程执行的代码书写在run方法内部，然后通过Timer类启动线程的执行。

在实际使用时，一个Timer可以启动任意多个TimerTask实现的线程，但是多个线程之间会存在阻塞。所以如果多个线程之间如果需要完全独立运行的话，最好还是一个Timer启动一个TimerTask实现。

 

import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;
/**
    了解
  Timer() 
  schedule(TimerTask task, Date time) 
  schedule(TimerTask task, Date firstTime, long period) 
  自学 quartz
 * @author W.Sky
 *
 */
public class TimeDemo01 {

	public static void main(String[] args) {
		Timer timer =new Timer();
		timer.schedule(new TimerTask(){

			@Override
			public void run() {
				System.out.println("so easy....");
			}}, new Date(System.currentTimeMillis()+1000), 200);
	}

}