黑马程序员:Java基础篇之多线程
2013-08-07 21:10
393 查看
Java基础篇之多线程
进程:是一个正在执行的应用程序。
每一个进程执行都有一个执行顺序。该顺序是一个执行路径,或者叫一个控制单元。
线程:就是进程中的一个独立的控制单元。
线程在控制着进程的执行。
一个进程中至少有一个线程。
Java VM启动的时候会有一个进程java.exe
该进程中至少一个线程负责java程序的执行,而且这个线程运行的代码存在于main方法中。
该线程称之为主线程。
扩展:其实JVM启动不止一个线程,还有负责垃圾回收机制的线程。
如何在一个自定义的代码中自定义一个线程呢?
通过对Java API的查找,Java已经提供了对线程这类事物的描述,Thread类,Runable接口。
创建新执行线程有两种方法:
一种方法是继承Thread类。
步骤:
1、 定义类继承Thread。
2、 复写Thread类的run方法。
目的:将自定义代码存储在run方法中,让线程运行。
3、 创建对象,调用线程的start方法。
该方法两个作用:启动线程,调用run方法。
发现运行结果每一次都不同。
因为多个线程都获取cpu的执行权,cpu执行到谁,谁就运行。
明确一点,在某一个时刻,只能有一个程序运行。(多核除外)
cpu在做着快速切换,以达到看上去是同时运行的效果。
我们可以形象地把多线程的运行行为看做是在互相抢夺cpu的执行权。
这就是多线程的一个特性:随机性。谁抢到谁执行,至于执行多长时间,cpu说的算。
为什么要覆盖run方法呢?
Thread类用于描述线程。
该类就定义一个功能,用于存储线程要运行的代码,该存储功能就是run方法。
也就是说Thread类中的run方法,用于存储线程要运行的代码。
线程的生命周期:
获取线程名称的方法:
1.super(name)获取父类中setName的方法
2.当前类中this.getName()获取name;
3.Thread.currentThread.getName()获取当前执行线程的名称,常用这个方法。
创建线程的第二种方式:实现Runnable接口
步骤:
1、 定义类实现Runnable接口;
2、 覆盖Runnable接口中的run方法;
将线程要运行的r代码存放在该run方法中。
3、 通过Thread类建立线程对象;
4、 将Runnable接口的子类对象作为实际参数传递给Thread类的构造方法;
为什么要将Runnable接口的子类对象传递给Thread的构造方法?
因为,自定义的run方法所属对象是Runnable接口的子类对象
所以要让线程去执行指定对象的run方法,就必须明确该run方法所属对象。
5、 调用Thread类的start方法开启线程并调用Runnable接口子类的run方法。
实现方式和继承方式有什么区别呢?
假如有一个类与另一个类有共性,向上抽取,形成了父类,但是需要用多线程执行,其就不能继承Thread方法,这样就出现了Runnable接口让其实现,用多实现的方法解决单继承的问题。
实现方式的好处:避免了单继承的局限性。
在定义线程时,建议使用。
两种方式区别:
继承Thread:线程代码存放Thread子类run方法中。
实现Runnable:线程代码存放在接口子类的run方法中。
多线程运行出现安全问题。
问题原因:
当多条语句在操作同一个线程共享数据时,一个线程对多条语句只执行了一部分,还没执行完,另一个线程参与进来执行,导致共享数据的错误。
解决办法:
对多条操作共享数据的语句,只能让一个线程都执行完。在执行过程中,其他线程不可参与。
Java对于多线程的安全问题提供了专业的解决方式,同步代码块。
synchronized(对象)
{
需要被同步的代码
}
对象如同锁,持有锁的线程可以再同步中执行。
没有持有锁的线程即使获取了cpu的执行权,也进不去,因为没有获取锁。
如同火车上的卫生间。
同步的前提:
1. 必须要是两个或者两个以上的线程。
2. 必须是多个线程使用同一个锁。
3. 必须保证同步中只能有一个线程在运行。
好处:解决了多线程安全问题。
弊端:多个线程需要判断锁,较为消耗资源。
如何判断一个程序是否有安全问题?
1、 明确哪些代码是多线程的运行代码;
2、 明确共享数据;
3、 明确多线程运行代码中哪些语句是操作共享数据的。
除了同步代码块外,还可有在方法前加synchronized,使之成为同步方法,同步方法中的代码。
同步方法用的是哪一个锁呢?
方法需要被对象调用,那么方法都有一个所属对象的引用,就是this。
所以同步方法使用的锁是this。
静态同步方法用的是哪一个锁呢?
静态同步方法是类方法,直接被类名调用,那么它的锁就是类的字节码文件对象。
所以静态同步方法使用的锁是<类名>.class
多线程-单例设计模式-懒汉式
饿汉式
classSingle
{
private static final Single s = newSingle();
private Single ()
{
}
public static Single getInstance()
{
returns;
}
}
懒汉式
classSingle
{
private static Single s = null;
private Single ()
{
}
public static Single getInstance()
{
if(s==null)//为了避免重复读锁,减少读锁次数。
{
synchronized (Single.class)
{
If(s==null)
s= new Single();
returns;
}
}
}
}
懒汉式:特点在于实例延时加载,多线程访问会出现安全问题,用双重判断的同步代码块进行同步,可解决安全问题,同时减少了不必要的读锁,节省资源。使用的锁是该类所属的字节码文件对象
死锁:两个线程都想到彼此的同步代码块内运行,但是彼此都不放锁,还都在继续要,一直要,就出现了死锁。
同步中嵌套同步,而锁不同。
写一个死锁程序:
线程间通讯:
其实就是多个线程在操作同一个资源,但是操作动作不同。
等待唤醒机制
wait();
notify();
notifyAll();
都使用在同步中,因为要对持有锁的线程操作,
只有同步才有锁。
为什么这些操作线程的方法要定义在object类中呢?
因为这些方法在操作同步中线程时,都必须要标识它们所操作的线程持有的锁,
只有同一个锁上的等待线程可以被同一个锁上的notify唤醒。
不可以对不同锁中的线程进行唤醒。
也就是说,等待和唤醒必须是同一个锁。
而锁可以是任意对象,所以可以被任意对象调用的方法定义在object类中。
为什么要定义notifyAll()?
因为需要唤醒对方线程。
因为只用notify,容易出现只唤醒本方线程的情况,导致程序中所有程序都wait。
JDK1.5中提供了多线程升级方案。
将同步synchronized替换成lock操作。
将object中的wait,notify,notifyAll,替换成Condition对象。
该对象可以lock锁进行获取。
停止线程
如何停止线程?
只有一种,run方法结束。
开启多线程运行,运行代码通常是循环结构。
只要控制住循环,就可以让run方法结束,也就是线程结束。
特殊情况:
当线程处于冻结状态,就不会读取循环结束标记,那么线程就不会结束。
当没有指定方式让冻结的线程恢复到运行状态时,这时需要对冻结进行清除。
此时使用interupt方法
该方法是结束线程的冻结状态,使线程回到运行状态中来,读取循环结束标记。
注:stop方法已经过时,不再使用了。
守护线程:
假如此时main线程中还有t1和t2线程,
我们对t1和t2线程使用t1.setDaemon(true)he t2.setDaemon(true),
那么这时t1和t2就变为main的守护线程。
当main线程结束,作为main的守护线程,t1和t2也跟着结束了。
Join方法:
要抛出InteruptedException
假如,现在main方法里有3个线程,分别为main,t1和t2。
main线程碰到t1线程的join,main线程交出cpu执行权给t1,自己处于冻结状态
t1得到执行权要么自己一个人玩,要么就跟t2线程一起玩(看join的位置)
等到自己玩完了,才会释放cpu执行权,
main线程才能得到cpu的执行权继续玩。
该方法常用于临时加一个线程运行。
多线程的优先级&yield方法
多线程中一共有10个优先级,
用setPriority()方法设置优先级,为了提高阅读性,一般不写数字。
而是使用
Thread.MAX_PRIORITY 优先级是10
Thread.MIN_PRIORITY 优先级是1
Thread.NORM_PRIORITY优先级是5
Yield()方法:
临时停止线程,强制让线程交出cpu执行权,有机会让线程平均使用cpu。
验证同锁:
死锁练习:
线程间通信:等待唤醒机制练习
eg.
Interrupt方法应用:
eg.
进程:是一个正在执行的应用程序。
每一个进程执行都有一个执行顺序。该顺序是一个执行路径,或者叫一个控制单元。
线程:就是进程中的一个独立的控制单元。
线程在控制着进程的执行。
一个进程中至少有一个线程。
Java VM启动的时候会有一个进程java.exe
该进程中至少一个线程负责java程序的执行,而且这个线程运行的代码存在于main方法中。
该线程称之为主线程。
扩展:其实JVM启动不止一个线程,还有负责垃圾回收机制的线程。
如何在一个自定义的代码中自定义一个线程呢?
通过对Java API的查找,Java已经提供了对线程这类事物的描述,Thread类,Runable接口。
创建新执行线程有两种方法:
一种方法是继承Thread类。
步骤:
1、 定义类继承Thread。
2、 复写Thread类的run方法。
目的:将自定义代码存储在run方法中,让线程运行。
3、 创建对象,调用线程的start方法。
该方法两个作用:启动线程,调用run方法。
发现运行结果每一次都不同。
因为多个线程都获取cpu的执行权,cpu执行到谁,谁就运行。
明确一点,在某一个时刻,只能有一个程序运行。(多核除外)
cpu在做着快速切换,以达到看上去是同时运行的效果。
我们可以形象地把多线程的运行行为看做是在互相抢夺cpu的执行权。
这就是多线程的一个特性:随机性。谁抢到谁执行,至于执行多长时间,cpu说的算。
为什么要覆盖run方法呢?
Thread类用于描述线程。
该类就定义一个功能,用于存储线程要运行的代码,该存储功能就是run方法。
也就是说Thread类中的run方法,用于存储线程要运行的代码。
线程的生命周期:
获取线程名称的方法:
1.super(name)获取父类中setName的方法
2.当前类中this.getName()获取name;
3.Thread.currentThread.getName()获取当前执行线程的名称,常用这个方法。
创建线程的第二种方式:实现Runnable接口
步骤:
1、 定义类实现Runnable接口;
2、 覆盖Runnable接口中的run方法;
将线程要运行的r代码存放在该run方法中。
3、 通过Thread类建立线程对象;
4、 将Runnable接口的子类对象作为实际参数传递给Thread类的构造方法;
为什么要将Runnable接口的子类对象传递给Thread的构造方法?
因为,自定义的run方法所属对象是Runnable接口的子类对象
所以要让线程去执行指定对象的run方法,就必须明确该run方法所属对象。
5、 调用Thread类的start方法开启线程并调用Runnable接口子类的run方法。
实现方式和继承方式有什么区别呢?
假如有一个类与另一个类有共性,向上抽取,形成了父类,但是需要用多线程执行,其就不能继承Thread方法,这样就出现了Runnable接口让其实现,用多实现的方法解决单继承的问题。
实现方式的好处:避免了单继承的局限性。
在定义线程时,建议使用。
两种方式区别:
继承Thread:线程代码存放Thread子类run方法中。
实现Runnable:线程代码存放在接口子类的run方法中。
多线程运行出现安全问题。
问题原因:
当多条语句在操作同一个线程共享数据时,一个线程对多条语句只执行了一部分,还没执行完,另一个线程参与进来执行,导致共享数据的错误。
解决办法:
对多条操作共享数据的语句,只能让一个线程都执行完。在执行过程中,其他线程不可参与。
Java对于多线程的安全问题提供了专业的解决方式,同步代码块。
synchronized(对象)
{
需要被同步的代码
}
对象如同锁,持有锁的线程可以再同步中执行。
没有持有锁的线程即使获取了cpu的执行权,也进不去,因为没有获取锁。
如同火车上的卫生间。
同步的前提:
1. 必须要是两个或者两个以上的线程。
2. 必须是多个线程使用同一个锁。
3. 必须保证同步中只能有一个线程在运行。
好处:解决了多线程安全问题。
弊端:多个线程需要判断锁,较为消耗资源。
如何判断一个程序是否有安全问题?
1、 明确哪些代码是多线程的运行代码;
2、 明确共享数据;
3、 明确多线程运行代码中哪些语句是操作共享数据的。
除了同步代码块外,还可有在方法前加synchronized,使之成为同步方法,同步方法中的代码。
同步方法用的是哪一个锁呢?
方法需要被对象调用,那么方法都有一个所属对象的引用,就是this。
所以同步方法使用的锁是this。
静态同步方法用的是哪一个锁呢?
静态同步方法是类方法,直接被类名调用,那么它的锁就是类的字节码文件对象。
所以静态同步方法使用的锁是<类名>.class
多线程-单例设计模式-懒汉式
饿汉式
classSingle
{
private static final Single s = newSingle();
private Single ()
{
}
public static Single getInstance()
{
returns;
}
}
懒汉式
classSingle
{
private static Single s = null;
private Single ()
{
}
public static Single getInstance()
{
if(s==null)//为了避免重复读锁,减少读锁次数。
{
synchronized (Single.class)
{
If(s==null)
s= new Single();
returns;
}
}
}
}
懒汉式:特点在于实例延时加载,多线程访问会出现安全问题,用双重判断的同步代码块进行同步,可解决安全问题,同时减少了不必要的读锁,节省资源。使用的锁是该类所属的字节码文件对象
死锁:两个线程都想到彼此的同步代码块内运行,但是彼此都不放锁,还都在继续要,一直要,就出现了死锁。
同步中嵌套同步,而锁不同。
写一个死锁程序:
线程间通讯:
其实就是多个线程在操作同一个资源,但是操作动作不同。
等待唤醒机制
wait();
notify();
notifyAll();
都使用在同步中,因为要对持有锁的线程操作,
只有同步才有锁。
为什么这些操作线程的方法要定义在object类中呢?
因为这些方法在操作同步中线程时,都必须要标识它们所操作的线程持有的锁,
只有同一个锁上的等待线程可以被同一个锁上的notify唤醒。
不可以对不同锁中的线程进行唤醒。
也就是说,等待和唤醒必须是同一个锁。
而锁可以是任意对象,所以可以被任意对象调用的方法定义在object类中。
为什么要定义notifyAll()?
因为需要唤醒对方线程。
因为只用notify,容易出现只唤醒本方线程的情况,导致程序中所有程序都wait。
JDK1.5中提供了多线程升级方案。
将同步synchronized替换成lock操作。
将object中的wait,notify,notifyAll,替换成Condition对象。
该对象可以lock锁进行获取。
停止线程
如何停止线程?
只有一种,run方法结束。
开启多线程运行,运行代码通常是循环结构。
只要控制住循环,就可以让run方法结束,也就是线程结束。
特殊情况:
当线程处于冻结状态,就不会读取循环结束标记,那么线程就不会结束。
当没有指定方式让冻结的线程恢复到运行状态时,这时需要对冻结进行清除。
此时使用interupt方法
该方法是结束线程的冻结状态,使线程回到运行状态中来,读取循环结束标记。
注:stop方法已经过时,不再使用了。
守护线程:
假如此时main线程中还有t1和t2线程,
我们对t1和t2线程使用t1.setDaemon(true)he t2.setDaemon(true),
那么这时t1和t2就变为main的守护线程。
当main线程结束,作为main的守护线程,t1和t2也跟着结束了。
Join方法:
要抛出InteruptedException
假如,现在main方法里有3个线程,分别为main,t1和t2。
main线程碰到t1线程的join,main线程交出cpu执行权给t1,自己处于冻结状态
t1得到执行权要么自己一个人玩,要么就跟t2线程一起玩(看join的位置)
等到自己玩完了,才会释放cpu执行权,
main线程才能得到cpu的执行权继续玩。
该方法常用于临时加一个线程运行。
多线程的优先级&yield方法
多线程中一共有10个优先级,
用setPriority()方法设置优先级,为了提高阅读性,一般不写数字。
而是使用
Thread.MAX_PRIORITY 优先级是10
Thread.MIN_PRIORITY 优先级是1
Thread.NORM_PRIORITY优先级是5
Yield()方法:
临时停止线程,强制让线程交出cpu执行权,有机会让线程平均使用cpu。
验证同锁:
class LockDemo { public static void main(String[] args) { User u = new User(1); Thread t1 = new Thread(u); Thread t2 = new Thread(u); t1.start(); try { Thread.sleep(10);throw InterruptedException; } catch (Exception e) { } u.flag = false; t2.start(); } } class User implements Runnable { private int count = 100; private int computer ; boolean flag = true ; public User(int computer) { this.computer = computer ; } public void run() { if(flag) { while(true) { //synchronized(User.class) synchronized(this) { if(count>0) { try { Thread.sleep(10); } catch (Exception e) { } System.out.println(Thread.currentThread().getName()+"..."+computer+"..."+count); computer++; count--; } } } } else while(true) { show(); } } public synchronized void show() { if(count>0) { try { Thread.sleep(10); } catch (Exception e) { } System.out.println(Thread.currentThread().getName()+"..."+computer+"......"+count); computer++; count--; } } }
死锁练习:
class AlwaysLockDemo { public static void main(String[] args) { User u=new User(); Thread t1 = new Thread(u); Thread t2 = new Thread(u); t1.start(); try { Thread.sleep(10); } catch (InterruptedException e) { } u.flag = false; t2.start(); } } class User implements Runnable { private int computer = 100; private int code = 1; boolean flag = true ; public void run() { if (flag) { while (true) { synchronized(User.class) { show(); } } } else while (true) show(); } public synchronized void show() { synchronized(User.class) { if (computer>0) { try { Thread.sleep(10); } catch (InterruptedException e) { } System.out.println(Thread.currentThread().getName()+"---"+computer+"---"+code); computer--; code++; } } } }
线程间通信:等待唤醒机制练习
eg.
import java.util.concurrent.locks.*; class LockConditionDemo { public static void main(String[] args) { Commander c = new Commander(); SoldierA a = new SoldierA(c); SoldierB b = new SoldierB(c); Thread t1 = new Thread(a); Thread t2 = new Thread(a); Thread t3 = new Thread(b); Thread t4 = new Thread(b); t1.start(); t2.start(); t3.start(); t4.start(); } } class Commander { String name ; int day = 1; boolean flag = false ; Lock lock = new ReentrantLock(); Condition A = lock.newCondition(); Condition B = lock.newCondition(); public void Awork(String name)throws InterruptedException { lock.lock(); try { while(flag) A.await(); this.name = name+"---"+day++; System.out.println(Thread.currentThread().getName()+"--上半夜站岗--"+this.name); flag = true ; B.signal(); } finally { lock.unlock(); } } public void Bwork(String name)throws InterruptedException { lock.lock(); try { while(!flag) B.await(); this.name = name+"---"+day++; System.out.println(Thread.currentThread().getName()+"------下半夜站岗------"+this.name); flag = false; A.signal(); } finally { lock.unlock(); } } } class SoldierA implements Runnable { private Commander com; SoldierA(Commander com) { this.com = com ; } public void run() { while (true) { try { com.Awork("小强"); } catch (InterruptedException e) { } } } } class SoldierB implements Runnable { private Commander com; SoldierB(Commander com) { this.com = com ; } public void run() { while (true) { try { com.Bwork("大黄"); } catch (InterruptedException e) { } } } }
Interrupt方法应用:
eg.
class InterruptedDemo { public static void main(String[] args) { Stone s = new Stone(); Thread t1=new Thread(s); Thread t2=new Thread(s); t1.start(); t2.start(); int num = 0; while (true) { if (num++==60) { t1.interrupt(); t2.interrupt(); break; } System.out.println(Thread.currentThread().getName()+"---"+num); } System.out.println("over"); } } class Stone implements Runnable { private boolean flag = true; public synchronized void run() { while (flag) { try { wait(); } catch (InterruptedException e) { System.out.println(Thread.currentThread().getName()+"---InterruptedException"); changeFlag(); } System.out.println(Thread.currentThread().getName()+"------run"); } } public void changeFlag() { flag=false; } }
相关文章推荐
- 黑马程序员_java基础篇之多线程
- 黑马程序员—【Java基础篇】之多线程
- 黑马程序员java基础篇----多线程总结(下)
- 黑马程序员_Java基础之多线程
- 黑马程序员——Java基础---多线程详解
- 黑马程序员--Java基础--多线程(一)
- 黑马程序员——Java学习笔记之③——“多线程”
- 黑马程序员—Java多线程
- 黑马程序员--Java多线程
- 黑马程序员_Java_多线程
- 黑马程序员-JAVA多线程总结
- 黑马程序员_java基础-多线程
- 黑马程序员——JAVA学习笔记——多线程
- 黑马程序员 知识点总结-Java多线程
- JAVA多线程编程基础篇-实战篇
- Java入门到精通——基础篇之多线程实现简单的PV操作的进程同步
- 黑马程序员_java多线程中的生产者与消费者
- hadoop学习序曲之java基础篇--java多线程
- 黑马程序员---java基础知识(四):多线程
- 黑马程序员——JAVA——多线程