多线程详细解析上

多线程

进程

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-s45atC8q-1595936761510)(images/进程概念.png)]

线程

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

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LUb953nf-1595936761516)(images/线程概念.jpg)]

线程的调度模型

每个线程都是具有优先级,优先级越高的线程,相对的会占用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);
    }
}

线程的随机性

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cPfLJf88-1595936761518)(images/线程的随机性.jpg)]

线程的内存图

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

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-N60eh7C2-1595936761522)(images/线程内存图.jpg)]

线程创建的问题

• 为什么要继承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);
	}
}

两种实现线程的方式区别

• 单继承,继承方式实现线程,有局限性
• 接口实现,可以多实现,避免了单继承的局限性
• 继承方式,耦合性比较强,线程和线程要执行的任务耦合一起
• 接口实现,线程和线程任务的分离效果,低耦合,面向对象的思想

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-I8SOIWHU-1595936761525)(images/实现线程方式的区别.jpg)]

线程名字的操作

获取名字

每个线程都有自己的名字,默认的

Thread类方法 String getName()

线程的默认名字是: Thread-0, Thread-1

public class MyThread  extends Thread{
	public void run() {
		//直接调用父类的方法getName()
		System.out.println("继承重写方法.."+super.getName());
	}
}

Thread类方法 :

• static Thread cuurentThread() 返回当前线程对象
  • 当前线程 : 静态方法写在哪个线程里面,哪个就是对当前线程
• Thread t = Thread.currentThread(); t.getName()获取线程名字的通用方式

设置名字

Thread类的方法setName(String 线程名)

不建议修改线程名字

线程安全

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

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

售票案例

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

现场有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();
	}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-feOiAqY7-1595936761526)(images/线程安全隐患的分析.jpg)]

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-- +"张");
  				}
  			}
  		}
  	}
  

同步工作原理

就是把对象锁 ( 唯一性 )

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YcK1Ntkz-1595936761528)(images/同步的原理.jpg)]

方法的优化

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-- +"张");
    }
    //}
}

死锁案例

多个线程,在争抢同一个锁对象的时候,造成程序的假死现象,卡住

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YOP5aADe-1595936761529)(images/死锁案例.jpg)]

public class DeadLock implements Runnable{

	//定义成员变量,控制线程的走向
	private boolean flag;
	
	
	public DeadLock(boolean flag) {
		this.flag = flag;
	}
	
	/*
	 * 实现死锁程序
	 */
	public void run() {
		while(true) {
			//判断flag=true
			//线程先进去A锁同步,在进入B锁同步
			if(flag) {
				synchronized ( LockA.locka ) {
					System.out.println("if..locka锁");
					synchronized( LockB.lockb ) {
						System.out.println("if..lockb锁");
					}
				}
			}
			//线程先进去B锁同步,在进去A锁同步
			else {
				synchronized( LockB.lockb ) {
					System.out.println("esle..lockb锁");
					synchronized( LockA.locka) {
						System.out.println("else..locka锁");
					}
				}
			}
		}
	}
}

// A类对象,做为锁来使用
public class LockA {
	//静态的成员变量,返回对象
	public static LockA locka = new LockA();
}

public class LockB {
	public static LockB lockb = new LockB();
}

public static void main(String[] args) {
    //创建接口Runnable实现类,成员变量设置为true
    DeadLock d1 = new DeadLock(true);
    //创建接口Runnable实现类,成员变量设置为false
    DeadLock d2 = new DeadLock(false);
    new Thread(d1).start();
    new Thread(d2).start();
}

匿名内部类实现线程

public static void main(String[] args) {
//		Runnable r = new Runnable() {
//			public void run() {
//				System.out.println("线程开启");
//			}
//		};
		
		new Thread(  new Runnable() {
			public void run() {
				System.out.println("线程开启");
			}
		}  ).start();
		
		new Thread() {
			public void run() {
				System.out.println("子类继承父类");
			}
		}.start();
	} 

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 个状态

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MwKjdi7i-1595936761530)(images/线程生命周期 - 副本.jpg)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qnIyHsSd-1595936761531)(images/线程状态图 - 副本.png)]