多线程作为java中的一个很重要的知识点,所以在学习中有必要总结一下,此篇文章会不多的更新,希望大神可以多多指教
一.线程的生命周期及五种基本状态
关于java中线程的生命周期,先看一下下面这张比较经典的图:
掌握了图中的各个知识点,也就掌握了java的多线程机制,不过我刚开是学习,所以很多都还不是很懂。。。。
通过百度,就简单介绍一下吧:
主要包括:
java线程具有五种基本状态
新建状态(New):当线程对象创建后,即进入了新建状态,如: Thread t = new MyThread();
就绪装填(Runnable):当调用线程对象的start()方法,即:t.start();,线程就进入了就绪状态。处于就绪状态的线程,只是说明此线程已经做好了准备,随时等待CPU调度执行,并不是说执行了t.start()此线程就会立即执行;
运行状态(Running):当CPU开始调度处于就绪状态的线程是,此线程才可以真正执行,即进入到运行状态。 特别注意的:就绪状态是进入运行状态的唯一入口,也就是说,线程要想进入运行状态执行,首先必须处于就绪状态中;
阻塞状态(Blocked):处于运行状态中的线程由于某种原因,暂时放弃对CPU的使用权,停止执行,此时进入阻塞状态,直到其进入到就绪状态,才有机会再次被CPU调用进入到运行状态。根据阻塞原因又可以分为三种:
a. 等待阻塞:运行状态中的线程执行wait()方法,使本线程进入到等待阻塞状态;
b.同步阻塞:线程在获取synchronized同步锁失败(因为锁被其他线程所占用),它会进入同步阻塞状态;
c.其他阻塞:通过调用线程sleep()或join()或发出I/O请求时,线程会进入到阻塞状态。当sleep()状态超市,join()等待线程终止或者因异常退出run()方法,该线程结束生命周期。
死亡状态(Dead):线程执行完了或者因异常退出了run()方法,该线程结束生命周期。
二.java多线程的创建及启动
java中线程的创建常见的三种基本形式
1.继承Thread类,重写该类的run()方法。
简单的说一下Thread的常用方法:
*start(),启动线程并执行相应的run()方法
* run(),子线程要执行的代码放入run()方法中
*currentThread(),静态的,调用当前的线程
*getName():获取此线程的名字
*setName():设置此线程的名字
*yield():调用此方法的线程释放当前CPU的执行权
*join():在A线程中调用B线程的join()方法,表示,当执行到此方法,A线程停止,直到B线程执行完毕,A线程再截止join()之后的代码执行
*isAlive():判断当前线程是否还存活
*sleep(long l):显示的让当前线程睡眠l毫秒
多线程的创建方式:通过继承的方式
/*
* 创建一个子线程,完成1-100之间自然数的输出。同样地,主线程执行同样的操作
* 创建多线程的第一种方式:继承java.lang.Thread类
*/
//1.创建一个继承于Thread的子类
class SubThread extends Thread{
//2.重写Thread类的run()方法.方法内实现此子线程要完成的功能
public void run(){
for(int i = 1;i <= 100;i++){
System.out.println(Thread.currentThread().getName() +":" + i);
}
}
}
public class TestThread {
public static void main(String[] args) {
//3.创建子类的对象
SubThread st1 = new SubThread();
SubThread st2 = new SubThread();
//4.调用线程的start():启动此线程;调用相应的run()方法
//一个线程只能够执行一次start()
//不能通过Thread实现类对象的run()去启动一个线程
st1.start();
//st.start();
//st.run();
st2.start();
for(int i = 1;i <= 100;i++){
System.out.println(Thread.currentThread().getName() +":" + i);
}
}
}
继承Thread类,通过重写run()方法定义一个新的线程类SubThread,其中的run()方法的方法体代表线程需要完成的任务,称为线程执行体。当创建此线程类对象时一个新的线程得以创建,并进入到线程新建状态。通过调用线程对象引用的start()方法,使得该线程进入就绪状态,此时线程并不一定会马上执行,这取决与CPU调度时机。
多线程的另一种创建:通过实现的方式
/*
* 创建多线程方式二:通过实现的方式
*/
//1.创建了一个实现了Runnable接口的类
class PrintNum1 implements Runnable{
//2.实现接口的抽象方法
public void run() {
for(int i = 1;i <= 100;i++) {
if(i % 2 == 0) {
System.out.println(Thread.currentThread().getName()+ ":" + i);
}
}
}
}
public class TestThread4 {
public static void main(String[] args) {
//3.创建一个Runnable接口实现类的对象
PrintNum1 p = new PrintNum1();
//p.start(); 此时只是实现了一个接口,这个接口只有一个run方法,而start这个方法是没有的
// p.run();要想启动一个多线程,必须调用start方法;
//4.将此对象作为形参传递给Thread类的构造器中,创建Thread类的对象,此对象即为一个线程
Thread t1 = new Thread(p);
//5.调用start()方法,启动线程并执行run();
t1.start();//启动线程,执行Thread对象生成时构造器的形参的对象的run方法
//在创建一个线程
Thread t2 = new Thread(p);
t2.start();
}
}
两种方式的对比:联系:class Thread implements Runnable
比较哪个好?实现的方式较好。①解决了单继承的局限性。②如果多个线程有共享数据的话,建议使用实现方式,同时,共享
数据所在的类可以作为Runnable接口的实现类。
线程里的常用方法:start() run() currentThread() getName() setName(String name) yield() join() sleep() isAlive()
getPriority() setPriority(int i); wait() notify() notifyAll()
三.线程的生命周期
四.线程的同步机制(重点、难点)
前提:如果我们创建的多个线程,存在着共享数据,那么就有可能出现线程的安全问题:当其中一个线程操作共享数据时,还未操作完成,
另外的线程就参与进来,导致对共享数据的操作出现问题。
解决方式:要求一个线程操作共享数据时,只有当其完成操作完成共享数据,其它线程才有机会执行共享数据。
方式一:同步代码块:
synchronized(同步监视器){
//操作共享数据的代码
}
注:1.同步监视器:俗称锁,任何一个类的对象都可以才充当锁。要想保证线程的安全,必须要求所有的线程共用同一把锁!
2.使用实现Runnable接口的方式创建多线程的话,同步代码块中的锁,可以考虑是this。如果使用继承Thread类的方式,慎用this!
3.共享数据:多个线程需要共同操作的变量。 明确哪部分是操作共享数据的代码。
方式二:同步方法:将操作共享数据的方法声明为synchronized。
比如:public synchronized void show(){ //操作共享数据的代码}
注:1.对于非静态的方法而言,使用同步的话,默认锁为:this。如果使用在继承的方式实现多线程的话,慎用!
2.对于静态的方法,如果使用同步,默认的锁为:当前类本身。以单例的懒汉式为例。 Class clazz = Singleton.class
总结:释放锁:wait();
不释放锁: sleep() yield() suspend() (过时,可能导致死锁)
死锁:不同的线程分别占用对方需要的同步资源不放弃,都在等待对方放弃自己需要的同步资源,就形成了线程的死锁
死锁是我们在使用同步时,需要避免的问题!
五.线程的通信:
如下的三个方法必须使用在同步代码块或同步方法中!
wait():当在同步中,执行到此方法,则此线程“等待”,直至其他线程执行notify()的方法,将其唤醒,唤醒后继续其wait()后的代码
notify()/notifyAll():在同步中,执行到此方法,则唤醒其他的某一个或所有的被wait的线程。
>例题:1.两个线程交替打印1-100自然数 2.生产者、消费者的例子
例子1:
package com.atguigu.java1;
/*线程通信,如下的三个关键字使用的话,都得在同步代码块或同步方法中
* wait():一旦一个线程执行到wait(),就释放当前的锁
* notify()或notifyAll(),唤醒wait的一个或所有的线程
* 用两个线程交替输出1-100.
*
*/
class PrintNum implements Runnable {
int num = 1;
public void run() {
while (true) {
synchronized (this) {
notify();
if (num <= 100) {
try {
Thread.currentThread().sleep(10);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + ":" + num);
num++;
}
else {
break;
}
try {
wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
}
public class Testexe {
public static void main(String[] args) {
PrintNum p = new PrintNum();
Thread t1 = new Thread(p);
Thread t2 = new Thread(p);
t1.setName("线程1");
t2.setName("线程2");
t1.start();
t2.start();
}
}
例子2:
package com.atguigu.java1;
/*
* 生产者/消费者问题
* 生产者(Productor)将产品交给店员(Clerk),而消费者(Customer)从店员
* 处取走产品,店员一次只能持有固定数量的产品,如果生产者试图生产更多的产品,店员会叫生产者停一下
* 如果店中有空位放产品再通知生产者继续生产,如果店中没有产品了,店员会告诉消费者等一下
* 如果店中有产品了再通知消费者过来取走商品
*
*
*
* 分析:
* 1.是否涉及到多线程的问题? 是! 生产者、消费者
* 2.是否涉及到共享数据? 是! 考虑线程安全问题
* 3.此共享数据是谁? 产品的数量
* 4.是否涉及到线程的通信? 存在着生产者和消费者的通信
*/
class Clerk{
//创建一个店员,里面的数据是共享数据.
int producter;
public synchronized void addProducter() {
if(producter >= 20) {
try {
wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}else {
producter++;
System.out.println(Thread.currentThread().getName() + ":生产了第" + producter + "个产品");
notifyAll();
}
}
public synchronized void reduceProducter() {
if(producter <= 0 ) {
try {
wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}else {
System.out.println(Thread.currentThread().getName() + ":消费了第" + producter + "个产品");
producter--;
notifyAll();
}
}
}
class Producter implements Runnable{
//创建一个生产者
Clerk clerk;
public Producter(Clerk clerk) {
this.clerk = clerk;
}
public void run() {
while(true) {
clerk.addProducter();
try {
Thread.currentThread().sleep(100);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
class Customers implements Runnable{
Clerk clerk;
public Customers(Clerk clerk) {
this.clerk = clerk;
}
public void run() {
while(true) {
clerk.reduceProducter();
try {
Thread.currentThread().sleep(100);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
public class TestProduceConsume {
public static void main(String[] args) {
Clerk clerk = new Clerk();
Producter p1 = new Producter(clerk);
Customers c1 = new Customers(clerk);
Thread t1 = new Thread(p1);
Thread t3 = new Thread(p1);
Thread t2 = new Thread(c1);
t1.setName("生产者1");
t3.setName("生产者2");
t2.setName("消费者1");
t1.start();
t2.start();
t3.start();
}
}