多线程的知识你了解多少？（一看就懂）

多线程的概念

在学习多线程之前，我们先来了解一下，进程与线程的关系；

进程

正在运行的程序.称为进程. 一个应用程序在内存中占用的资源,才是进程

线程

线程 : 是进程中的某一功能,开启了一条让CPU来执行路径,路径就是线程

线程就是一条路,CPU去内存中取出数据执行。

线程的调度模型

每个线程都是具有优先级,优先级越高的线程,相对的会占用CPU的资源会更多.每个线程都是采用默认的优先级,轮流的使用CPU的资源,平均分配

Java中实现线程程序(一)

线程也是对象,对象都是由类创建

java.lang.Thread 类,线程对象类

继承Thread类

实现步骤:

• 定义类继承Thread
• 子类重写方法run
• 创建子类的对象
• 调用方法start()启动线程

 public class MyThread extends Thread{
	public void run() {
		for(int i = 0 ; i < 100; i++) {			
			System.out.println("子类重写方法run..."+i);
		}
	}
}

public static void main(String[] args) {
    //创建Thread类的子类对象
    MyThread my = new MyThread();
    //对象调用方法start()启动线程
    my.start();

    for(int i = 0 ; i < 100; i++) {	
        System.out.println("main方法..."+i);
    }
}

线程的随机性

线程的内存图

每次启动一个新的线程,就会创建出新的栈内存,运行方法run()

开启的线程越多,内存消耗越大. 栈内存(线程栈,私有)

线程创建的问题

• 为什么要继承Thread类
  • Thread是线程对象,继承Thread,我们自己定义的类也是线程对象
• 为什么要重写run方法
  • 线程每次要运行什么程序,这是未知的,比如,程序运行循环,运行创建对象,运行IO复制
  • sun公司 : 无论你要做什么事情,线程要完成的事情,都写在run()中
• 启动线程为什么不调用run(),调用start()
  • start()启动线程, JVM调用run()
  • start()方法最终执行的是start0(),是本地方法,C++写出来,和操作系统交互,启动线程是操作系统的事情

Java中实现线程程序(二)

实现接口的方式

实现步骤:

• 定义类实现接口Runnable
• 重写方法run()
• 创建Thread类对象
  • 构造方法 Thread(Runnable target)传递Runnable接口实现类
• 调用Thread类方法strat()启动线程

public class MyRunnable implements Runnable {
	public void run() {
		for(int i = 0 ; i < 100 ; i++) {
			System.out.println("实现类重写方法run..."+i);
		}
	}
}

public static void main(String[] args) {
	Runnable r = new MyRunnable();
	//创建Thread类对象,传递Runnable接口实现类对象
	Thread thread = new Thread(r);
	//Thread类方法start()启动线程
	thread.start();
	for(int i = 0 ; i < 100 ; i ++) {
		System.out.println("main..."+i);
	}
}

两种实现线程的方式区别

• 单继承,继承方式实现线程,有局限性

• 接口实现,可以多实现,避免了单继承的局限性

• 继承方式,耦合性比较强,线程和线程要执行的任务耦合一起

• 接口实现,线程和线程任务的分离效果,低耦合,面向对象的思想

• 线程安全

  开发的是多线程的程序,如果出现了线程的安全问题,程序人员是最大的责任人.

  安全问题产生 : 必须是多线程程序,争夺同一个资源

售票案例

电影票源是固定值,常量. 网络售票,现场自动售票机,人工窗口

现场有3个人工窗口,同时售票：

public class Ticket implements Runnable {
	//定义100张
	private int tickets = 100;
	
	//线程调用的方法,售票工作
	public void run() {
		//票数是0的时候,停止了
		while(true) {
			if(tickets > 0) {
				System.out.println("出售第"+tickets-- +"张");
			}
		}
	}
}

public static void main(String[] args) {
		//创建接口实现类对象
		Ticket ticket = new Ticket();
		//创建3个线程
		Thread t0 = new Thread( ticket );
		Thread t1 = new Thread( ticket );
		Thread t2 = new Thread( ticket );
		
		//启动线程
		t0.start();
		t1.start();
		t2.start();
	}

Thread.sleep(long 毫秒) 模拟出了,产生错误票的过程

public void run() {
    //票数是0的时候,停止了
    while(true) {
        if(tickets > 0) {
            //线程休眠,Thread类的静态方法sleep
            try {
                Thread.sleep(50);
            }catch(Exception ex) {}
            System.out.println("出售第"+tickets-- +"张");
        }
    }
}

解决安全问题

思想 : 当一个线程没有完成售票工作之前,其他的线程不能参与卖票

同步技术 : 保证线程安全的解决办法

• 同步技术:

  • 关键字 synchronized
  • 任意对象
  • 线程操作的共享资源

• 同步的写法格式 :

synchronized( 任意的对象 ){
 	写的是线程操作的所有共享资源
 }
 同步代码块

private Object obj = new Object();
	
	//线程调用的方法,售票工作
	public void run() {
		//票数是0的时候,停止了
		while(true) {
			synchronized( obj ) {
				if(tickets > 0) {
					//线程休眠,Thread类的静态方法sleep
					try {
						Thread.sleep(5);
					}catch(Exception ex) {}
					System.out.println(Thread.currentThread().getName()+ "出售第"+tickets-- +"张");
				}
			}
		}
	}

同步工作原理

就是把对象锁 ( 唯一性 )

线程判断锁,获取锁,释放锁, 一旦线程安全,运行速度下降. 必须牺牲速度,保证数据安全性；

方法的优化

public void run() {
		//调用售票的方法
		while(true) {
			saleTicket();
		}
	}
//定义方法,专门处理售票  tickets--
public void saleTicket() {
    synchronized( obj ) {
        if(tickets > 0) {
            //线程休眠,Thread类的静态方法sleep
            try {
                Thread.sleep(5);
            }catch(Exception ex) {}
            System.out.println(Thread.currentThread().getName()+ "出售第"+tickets-- +"张");
        }
 }

方法saleTicket()出现了一个情况,整个的方法里面,所有程序,都是线程操作的共享数据.不在使用同步的代码块了,可以同步整个的方法

//方法的修饰符位置,使用同步关键字
public synchronized void saleTicket() {
    if(tickets > 0) {
    //线程休眠,Thread类的静态方法sleep
    try {
    	Thread.sleep(5);
    }catch(Exception ex) {}
    	System.out.println(Thread.currentThread().getName()+ "出售第"+tickets-- +"张");
    }
}

同步方法中也存在对象锁吗

同步方法中的锁,是当前对象的引用 : this

静态的同步方法中,锁肯定不是this

是当前类的对象, Ticket.class文件也是对象

静态的同步方法中,锁对象是当前类的class文件对象.

任何一个数据类型,都会有一个静态的属性,属性的名字就是class

public static synchronized void saleTicket() {
    //synchronized(Ticket.class) {
    if(tickets > 0) {
    //线程休眠,Thread类的静态方法sleep
    try {
    	Thread.sleep(5);
    }catch(Exception ex) {}
    	System.out.println(Thread.currentThread().getName()+ "出售第"+tickets-- +"张");
    }
    //}
}

Lock接口

JDK1.5出现的接口

java.util.concurrent.locks.Lock

替代synchronized,更加的灵活

• Lock接口的方法
  • void lock()获取锁
  • void unlock() 释放锁
  • 实现类ReentrantLock

public class Ticket implements Runnable {
	//定义100张
	private int tickets = 100;
	//创建Lock接口实现类对象
	private Lock lock = new ReentrantLock();
	
	public void run() {
		//调用售票的方法
		while(true) {
			//获取锁
			lock.lock();
			if(tickets > 0) {
                //线程休眠,Thread类的静态方法sleep
                try {
                    Thread.sleep(5);
                }catch(Exception ex) {}
                System.out.println(Thread.currentThread().getName()+ "出售第"+tickets-- +"张");
			}
			//释放锁
			lock.unlock();
		}
	}
}

线程的生命周期,线程的状态

线程在他的一生中,创建到死亡,经过多个状态.

线程在某一个时刻,只能处于一种状态

线程共有 6 个状态；