黑马程序员8. 多线程
2014-07-05 20:48
281 查看
-------android培训、java培训、java学习型技术博客、期待与您交流!
----------
今天学习了毕老师java基础第11天的内容,在这里总结一下。
每一个进程都有一个执行顺序。该顺序是一个执行路径,或者叫一个控制单元。
线程:就是进程中的一个独立的控制单元。
线程在控制着进程的执行。
一个进程中至少有一个线程。
无论是QQ还是迅雷,它们启动都会在内存中分配一块内存空间,进程就是用于标识这个空间的,它用于封装里面的控制单元。
Java VM 启动的时候会有一个进程java.exe.
该进程中至少一个线程负责java程序的执行。
而且这个线程运行的代码存在于main方法中。
该线程称之为主线程。
扩展:其实更细节说明jvm,jvm启动不止一个线程,还有负责垃圾回收机制的线程。
1,如何在自定义的代码中,自定义一个线程呢?
通过对api的查找,java已经提供了对线程这类事物的描述。就是Thread类。
创建线程的第一种方式:继承Thread类。
步骤:
1,定义类继承Thread。
2,复写Thread类中的run方法。
目的:将自定义代码存储在run方法。让线程运行。
3,调用线程的start方法,
该方法两个作用:启动线程,调用run方法。
发现运行结果每一次都不同。
因为多个线程都获取cpu的执行权。cpu执行到谁,谁就运行。
明确一点,在某一个时刻,只能有一个程序在运行。(多核除外)
cpu在做着快速的切换,以达到看上去是同时运行的效果。
我们可以形象把多线程的运行行为在互相抢夺cpu的执行权。
这就是多线程的一个特性:随机性。谁抢到谁执行,至于执行多长,cpu说的算。
为什么要覆盖run方法呢?
Thread类用于描述线程。
该类就定义了一个功能,用于存储线程要运行的代码。该存储功能就是run方法。
也就是说Thread类中的run方法,用于存储线程要运行的代码。
线程都要自己默认的名称:Thread-编号,该编号从0开始。
static Thread currentThread():获取当前线程对象。
getName(): 获取线程名称。
设置线程名称:setName或者构造函数。
线程状态图:
步骤:
1,定义类实现Runnable接口
2,覆盖Runnable接口中的run方法。
将线程要运行的代码存放在该run方法中。
3,通过Thread类建立线程对象。
4,将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数。
为什么要将Runnable接口的子类对象传递给Thread的构造函数。
因为,自定义的run方法所属的对象是Runnable接口的子类对象。
所以要让线程去执行指定对象的run方法。就必须明确该run方法所属对象。
5,调用Thread类的start方法开启线程并调用Runnable接口子类的run方法。
实现方式和继承方式有什么区别呢?
实现方式好处:避免了单继承的局限性。
在定义线程时,建议使用实现方式。
两种方式区别:
继承Thread:线程代码存放Thread子类run方法中。
实现Runnable,线程代码存在接口的子类的run方法。
模拟票数出负数,使用Thread类的public static void sleep(long millis) throws InterruptedException方法:
接口的方法不能抛只能try:
通过分析,发现,打印出0,-1,-2等错票。
多线程的运行出现了安全问题。
问题的原因:
当多条语句在操作同一个线程共享数据时,一个线程对多条语句只执行了一部分,还没有执行完,
另一个线程参与进来执行。导致共享数据的错误。
解决办法:
对多条操作共享数据的语句,只能让一个线程都执行完。在执行过程中,其他线程不可以参与执行。
Java对于多线程的安全问题提供了专业的解决方式。
就是同步代码块。
synchronized(对象)
{
需要被同步的代码
}
原理:
对象标志位(锁旗标,锁,监视器)有两位0和1,线程0进入同步代码块之后,会把对象标志位从1(开)变成0(关)。然后0线程才去判断if语句,sleep(10)之后,执行权被释放。线程1紧接着获得了执行权,这时它要判断标志位,是0,这样,它就进不去了,所以此时,同步里面只有0线程在。当0线程出同步的时候,它会将对象标志位设为1。
对象如同锁。持有锁的线程可以在同步中执行。
没有持有锁的线程即使获取cpu的执行权,也进不去,因为没有获取锁。
同步的前提:
1,必须要有两个或者两个以上的线程。
2,必须是多个线程使用同一个锁。
必须保证同步中只能有一个线程在运行。
好处:解决了多线程的安全问题。
弊端:多个线程需要判断锁,较为消耗资源。
1,明确哪些代码是多线程运行代码。(run(),add())
2,明确共享数据。(Bank b, int sum)
3,明确多线程运行代码中哪些语句是操作共享数据的。
函数和同步代码块都是用来封装代码的,函数也可以具备同步性:
同步有两种表现形式,同步代码块和同步函数。
把需要同步的代码单独封装成一个方法:
this.show();
函数需要被对象调用。那么函数都有一个所属对象的引用,就是this。
所以同步函数使用的锁就是this。
验证:
都在show中执行,原因:
程序中有3个线程,主线程,t1和t2。t1.start()之后,t1处于临时状态,有资格,但是没有执行权,这时候主线程拥有执行权。主线程有可能会瞬间执行完t1.start()和t.flag = false。可以让主线程停10ms:
出现了0。同步代码块和同步函数使用的是两个不同的锁,一个是obj,一个是this。
函数可以用static修饰。
如果同步函数被静态修饰后,使用的锁是什么呢?
通过验证,发现不在是this。因为静态方法中也不可以定义this。
静态进内存时,内存中没有本类对象,但是一定有该类对应的字节码文件对象。
类名.class 该对象的类型是Class
静态的同步方法,使用的锁是该方法所在类的字节码文件对象。 类名.class
这里是Ticket.class
public static synchronized Single getInstance()
但是加了同步后会比较低效,因为每次都要判断:
懒汉式和饿汉式的不同:懒汉式会有实例的延迟加载。如果多线程访问时,懒汉式会出现安全问题,可以用同步来解决,但是效率比较低,可以用双重判断来提高效率。加同步的时候用的锁是该类所属的字节码文件对象。
这代码要背下来。面试会考。
发现卡住不动了。
死锁举例:
面试可能会让写出一个死锁的程序。
-------android培训、java培训、java学习型技术博客、期待与您交流!
----------
----------
今天学习了毕老师java基础第11天的内容,在这里总结一下。
多进程
进程:是一个正在执行中的程序。每一个进程都有一个执行顺序。该顺序是一个执行路径,或者叫一个控制单元。
线程:就是进程中的一个独立的控制单元。
线程在控制着进程的执行。
一个进程中至少有一个线程。
无论是QQ还是迅雷,它们启动都会在内存中分配一块内存空间,进程就是用于标识这个空间的,它用于封装里面的控制单元。
Java VM 启动的时候会有一个进程java.exe.
该进程中至少一个线程负责java程序的执行。
而且这个线程运行的代码存在于main方法中。
该线程称之为主线程。
扩展:其实更细节说明jvm,jvm启动不止一个线程,还有负责垃圾回收机制的线程。
1,如何在自定义的代码中,自定义一个线程呢?
通过对api的查找,java已经提供了对线程这类事物的描述。就是Thread类。
创建线程的第一种方式:继承Thread类。
步骤:
1,定义类继承Thread。
2,复写Thread类中的run方法。
目的:将自定义代码存储在run方法。让线程运行。
3,调用线程的start方法,
该方法两个作用:启动线程,调用run方法。
发现运行结果每一次都不同。
因为多个线程都获取cpu的执行权。cpu执行到谁,谁就运行。
明确一点,在某一个时刻,只能有一个程序在运行。(多核除外)
cpu在做着快速的切换,以达到看上去是同时运行的效果。
我们可以形象把多线程的运行行为在互相抢夺cpu的执行权。
这就是多线程的一个特性:随机性。谁抢到谁执行,至于执行多长,cpu说的算。
为什么要覆盖run方法呢?
Thread类用于描述线程。
该类就定义了一个功能,用于存储线程要运行的代码。该存储功能就是run方法。
也就是说Thread类中的run方法,用于存储线程要运行的代码。
线程都要自己默认的名称:Thread-编号,该编号从0开始。
static Thread currentThread():获取当前线程对象。
getName(): 获取线程名称。
设置线程名称:setName或者构造函数。
class Test extends Thread { Test(String name) { super(name); } public void run() { for(int x=0; x<60; x++) { System.out.println((Thread.currentThread()==this)+"..."+this.getName()+" run..."+x); } } } class ThreadTest { public static void main(String[] args) { Test t1 = new Test("one---"); Test t2 = new Test("two+++"); t1.start(); t2.start(); for(int x=0; x<60; x++) { System.out.println("main....."+x); } } }t1和t2里面的x是不一样的,run方法存在于栈内存中,每个run方法中有自己的局部变量。
线程状态图:
runable接口
创建线程的第二种方式:实现Runable接口class Ticket implements Runnable//extends Thread { private int tick = 100; public void run() { while(true) { if(tick>0) { System.out.println(Thread.currentThread().getName()+"....sale : "+ tick--); } } } } class TicketDemo { public static void main(String[] args) { Ticket t = new Ticket(); Thread t1 = new Thread(t);//创建了一个线程; Thread t2 = new Thread(t);//创建了一个线程; Thread t3 = new Thread(t);//创建了一个线程; Thread t4 = new Thread(t);//创建了一个线程; t1.start(); t2.start(); t3.start(); t4.start(); } }
步骤:
1,定义类实现Runnable接口
2,覆盖Runnable接口中的run方法。
将线程要运行的代码存放在该run方法中。
3,通过Thread类建立线程对象。
4,将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数。
为什么要将Runnable接口的子类对象传递给Thread的构造函数。
因为,自定义的run方法所属的对象是Runnable接口的子类对象。
所以要让线程去执行指定对象的run方法。就必须明确该run方法所属对象。
5,调用Thread类的start方法开启线程并调用Runnable接口子类的run方法。
实现方式和继承方式有什么区别呢?
实现方式好处:避免了单继承的局限性。
在定义线程时,建议使用实现方式。
两种方式区别:
继承Thread:线程代码存放Thread子类run方法中。
实现Runnable,线程代码存在接口的子类的run方法。
多线程的安全问题
class Ticket implements Runnable { private int tick = 1000; public void run() { while(true) { if(tick>0) { System.out.println(Thread.currentThread().getName()+"....sale : "+ tick--); } } } } class TicketDemo2 { public static void main(String[] args) { Ticket t = new Ticket(); Thread t1 = new Thread(t); Thread t2 = new Thread(t); Thread t3 = new Thread(t); Thread t4 = new Thread(t); t1.start(); t2.start(); t3.start(); t4.start(); } }票数可能出现负数:
模拟票数出负数,使用Thread类的public static void sleep(long millis) throws InterruptedException方法:
接口的方法不能抛只能try:
class Ticket implements Runnable { private int tick = 1000; public void run() { while(true) { if(tick>0) { try{Thread.sleep(10);}catch(Exception e){} System.out.println(Thread.currentThread().getName()+"....sale : "+ tick--); } } } }<img src="" alt="" style="font-family: Arial, Helvetica, sans-serif; background-color: rgb(255, 255, 255);" />
通过分析,发现,打印出0,-1,-2等错票。
多线程的运行出现了安全问题。
问题的原因:
当多条语句在操作同一个线程共享数据时,一个线程对多条语句只执行了一部分,还没有执行完,
另一个线程参与进来执行。导致共享数据的错误。
解决办法:
对多条操作共享数据的语句,只能让一个线程都执行完。在执行过程中,其他线程不可以参与执行。
Java对于多线程的安全问题提供了专业的解决方式。
就是同步代码块。
synchronized(对象)
{
需要被同步的代码
}
class Ticket implements Runnable { private int tick = 100; Object obj = new Object(); public void run() { while(true) { synchronized(obj) { if(tick>0) {try{Thread.sleep(10);}catch(Exception e){} System.out.println(Thread.currentThread().getName()+"....sale : "+ tick--); } } } } }
原理:
对象标志位(锁旗标,锁,监视器)有两位0和1,线程0进入同步代码块之后,会把对象标志位从1(开)变成0(关)。然后0线程才去判断if语句,sleep(10)之后,执行权被释放。线程1紧接着获得了执行权,这时它要判断标志位,是0,这样,它就进不去了,所以此时,同步里面只有0线程在。当0线程出同步的时候,它会将对象标志位设为1。
对象如同锁。持有锁的线程可以在同步中执行。
没有持有锁的线程即使获取cpu的执行权,也进不去,因为没有获取锁。
同步的前提:
1,必须要有两个或者两个以上的线程。
2,必须是多个线程使用同一个锁。
必须保证同步中只能有一个线程在运行。
好处:解决了多线程的安全问题。
弊端:多个线程需要判断锁,较为消耗资源。
存钱的例子
class Bank { private int sum; public void add(int n) { sum = sum + n; System.out.println("sum="+sum); } } class Cus implements Runnable { private Bank b = new Bank(); public void run() { for (int x=0;x<3 ;x++ ) { b.add(300); } } } class BankDemo { public static void main(String[] args) { Cus c = new Cus(); Thread t1 = new Thread(c); Thread t2 = new Thread(c); t1.start(); t2.start(); } }如何找问题:
1,明确哪些代码是多线程运行代码。(run(),add())
2,明确共享数据。(Bank b, int sum)
3,明确多线程运行代码中哪些语句是操作共享数据的。
class Bank { private int sum; Object obj = new Object(); public void add(int n) { synchronized(obj) { sum = sum + n; try{Thread.sleep(10);}catch(Exception e){} System.out.println("sum="+sum); } } }运行结果:
函数和同步代码块都是用来封装代码的,函数也可以具备同步性:
class Bank { private int sum; public synchronized void add(int n) { sum = sum + n; try{Thread.sleep(10);}catch(Exception e){} System.out.println("sum="+sum); } }运行结果也正确。
同步有两种表现形式,同步代码块和同步函数。
同步函数的锁是this
class Ticket implements Runnable { private int tick = 1000; public synchronized void run() { while(true) { if(tick>0) { try{Thread.sleep(10);}catch(Exception e){} System.out.println(Thread.currentThread().getName()+"....sale : "+ tick--); } } } } class TicketDemo2 { public static void main(String[] args) { Ticket t = new Ticket(); Thread t1 = new Thread(t); Thread t2 = new Thread(t); Thread t3 = new Thread(t); Thread t4 = new Thread(t); t1.start(); t2.start(); t3.start(); t4.start(); } }发现所有的票都是0线程卖的。这是因为0线程进入同步函数后就把它锁上了,这样其他线程就进不去了。并不是run()函数都需要封装。
把需要同步的代码单独封装成一个方法:
class Ticket implements Runnable { private int tick = 1000; public void run() { while(true) { show(); } } public synchronized void show() { if(tick>0) { try{Thread.sleep(10);}catch(Exception e){} System.out.println(Thread.currentThread().getName()+"....sale : "+ tick--); } } }那么同步函数用的是哪一个锁呢?
this.show();
函数需要被对象调用。那么函数都有一个所属对象的引用,就是this。
所以同步函数使用的锁就是this。
验证:
/* 通过该程序进行验证。 使用两个线程来买票。 一个线程在同步代码块中。 一个线程在同步函数中。 都在执行买票动作。 */ class Ticket implements Runnable { private int tick = 100; Object obj = new Object(); boolean flag = true; public void run() { if(flag) { while(true) { synchronized(obj) { if(tick>0) { try{Thread.sleep(10);}catch(Exception e){} System.out.println(Thread.currentThread().getName()+"....code : "+ tick--); } } } } else while(true) show(); } public synchronized void show() { if(tick>0) { try{Thread.sleep(10);}catch(Exception e){} System.out.println(Thread.currentThread().getName()+"....show.... : "+ tick--); } } } class TicketDemo2 { public static void main(String[] args) { Ticket t = new Ticket(); Thread t1 = new Thread(t); Thread t2 = new Thread(t); t1.start(); t.flag = false; t2.start(); } }运行结果:
都在show中执行,原因:
程序中有3个线程,主线程,t1和t2。t1.start()之后,t1处于临时状态,有资格,但是没有执行权,这时候主线程拥有执行权。主线程有可能会瞬间执行完t1.start()和t.flag = false。可以让主线程停10ms:
class TicketDemo2 { public static void main(String[] args) { Ticket t = new Ticket(); Thread t1 = new Thread(t); Thread t2 = new Thread(t); t1.start(); try{Thread.sleep(10);}catch(Exception e){} t.flag = false; t2.start(); } }运行结果:
出现了0。同步代码块和同步函数使用的是两个不同的锁,一个是obj,一个是this。
函数可以用static修饰。
class Ticket implements Runnable { private static int tick = 100; Object obj = new Object(); boolean flag = true; public void run() { if(flag) { while(true) { synchronized(obj) { if(tick>0) { try{Thread.sleep(10);}catch(Exception e){} System.out.println(Thread.currentThread().getName()+"....code : "+ tick--); } } } } else while(true) show(); } public static synchronized void show() { if(tick>0) { try{Thread.sleep(10);}catch(Exception e){} System.out.println(Thread.currentThread().getName()+"....show.... : "+ tick--); } } } class StaticMethodDemo { public static void main(String[] args) { Ticket t = new Ticket(); Thread t1 = new Thread(t); Thread t2 = new Thread(t); t1.start(); try{Thread.sleep(10);}catch(Exception e){} t.flag = false; t2.start(); } }运行结果出现了0。
如果同步函数被静态修饰后,使用的锁是什么呢?
通过验证,发现不在是this。因为静态方法中也不可以定义this。
静态进内存时,内存中没有本类对象,但是一定有该类对应的字节码文件对象。
类名.class 该对象的类型是Class
静态的同步方法,使用的锁是该方法所在类的字节码文件对象。 类名.class
这里是Ticket.class
单例设计模式
//饿汉式 class Single { private static final Single s = new Single(); private Single(){} public static Single getInstance() { return s; } } //懒汉式 class Single { private static Single s = null; private Single(){} public static Single getInstance() { if(s==null)//延迟加载 s= new Single();//对象被延迟了 return s; }可能存在多个线程同时访问s,会产生安全隐患:
public static synchronized Single getInstance()
但是加了同步后会比较低效,因为每次都要判断:
class Single { private static Single s = null; private Single(){} public static Single getInstance() { if (s==null) { synchronized(Single.class) { if(s==null)//延迟加载 s= new Single();//对象被延迟了 } } return s; }一个初始化完了之后,以后的线程都不用判断锁了。
懒汉式和饿汉式的不同:懒汉式会有实例的延迟加载。如果多线程访问时,懒汉式会出现安全问题,可以用同步来解决,但是效率比较低,可以用双重判断来提高效率。加同步的时候用的锁是该类所属的字节码文件对象。
这代码要背下来。面试会考。
死锁
/* 死锁。 同步中嵌套同步。 */ class Ticket implements Runnable { private int tick = 1000; Object obj = new Object(); boolean flag = true; public void run() { if(flag) { while(true) { synchronized(obj) { show(); } } } else while(true) show(); } public synchronized void show()//this { synchronized(obj) { if(tick>0) { try{Thread.sleep(10);}catch(Exception e){} System.out.println(Thread.currentThread().getName()+"....code : "+ tick--); } } } } class DeadLockDemo { public static void main(String[] args) { Ticket t = new Ticket(); Thread t1 = new Thread(t); Thread t2 = new Thread(t); t1.start(); try{Thread.sleep(10);}catch(Exception e){} t.flag = false; t2.start(); } }运行结果:
发现卡住不动了。
死锁举例:
class Test implements Runnable { private boolean flag; Test(boolean flag) { this.flag = flag; } public void run() { if(flag) { while(true) { synchronized(MyLock.locka) { System.out.println(Thread.currentThread().getName()+"...if locka "); synchronized(MyLock.lockb) { System.out.println(Thread.currentThread().getName()+"..if lockb"); } } } } else { while(true) { synchronized(MyLock.lockb) { System.out.println(Thread.currentThread().getName()+"..else lockb"); synchronized(MyLock.locka) { System.out.println(Thread.currentThread().getName()+".....else locka"); } } } } } } class MyLock { static Object locka = new Object(); static Object lockb = new Object(); } class DeadLockTest { public static void main(String[] args) { Thread t1 = new Thread(new Test(true)); Thread t2 = new Thread(new Test(false)); t1.start(); t2.start(); } }运行结果:
面试可能会让写出一个死锁的程序。
-------android培训、java培训、java学习型技术博客、期待与您交流!
----------
相关文章推荐
- 黑马程序员——第十一天(Java面向对象-多线程一)
- 黑马程序员——第十四篇: 打印流、随机读写、对象序列化、多线程
- 黑马程序员——多线程
- 黑马程序员——【Java基础】——多线程
- 黑马程序员——多线程总结1
- 黑马程序员_多线程
- 黑马程序员_Java基础_多线程_11
- 黑马程序员——多线程
- 黑马程序员——多线程
- 黑马程序员:Java基础总结----多线程安全性&同步
- 黑马程序员——Java异常&多线程
- 黑马程序员——多线程
- 黑马程序员_多线程(5) 同步工具类&空中网面试题
- 黑马程序员——Java学习总结:多线程和网络编程
- 黑马程序员---java多线程 学习笔记
- 黑马程序员——java编程那些事儿____多线程(二)
- 黑马程序员-----Java基础学习多线程
- 黑马程序员—多线程
- 黑马程序员(1)---初学多线程
- 黑马程序员----多线程基础