黑马程序员——java基础---多线程
2015-02-21 09:20
267 查看
------Java培训、Android培训、iOS培训、.Net培训、期待与您交流! -------
1、进程
1、继承方式
1、图示
1、同步的由来
1、单事件同步
一、基本概念
1、进程
是一个正在执行中的程序。每一个进程执行都有一个执行顺序。该顺序是一个执行路径,或者叫一个控制单元。
2、线程
就是进程中的一个独立的控制单元。线程在控制着进程的执行。
3、多线程
一个进程中至少有一个线程。Java VM 启动的时候会有一个进程java.exe.该进程中至少一个线程负责java程序的执行,而且这个线程运行的代码存在于main方法中,该线程称之为主线程。jvm启动不止一个线程,还有负责垃圾回收机制的线程。由此可知,Java VM就是一个多线程的程序。
1)优点
多条线程并发运行,提高了程序执行效率,充分发挥了人多力量大的优势;能够处理了单线程无法完成的工作。
2)缺点
多线程的运行并非所有线程同时运行,而是CPU在不同线程间做着高速的切换,这是由CPU的运行原理决定的。每个线程的运行却是独立的,那么,就有可能造成多个线程对同一数据的重复操作,这一现象称为线程安全问题。后面有详细描述。
4、思考:
什么情况下,需要用到多线程?
1、必须要分工协作才能完成事件;
2、可以明显提高效率,却不会影响到程序的正常运行。
多线程的特性?
独立、随机。
二、创建方式
1、继承方式
通过对api的查找,java已经提供了对线程这类事物的描述。就Thread类。
创建线程的第一种方式:继承Thread类。
步骤:
a、定义类继承Thread。
b、复写Thread类中的run方法。的:将自定义代码存储在run方法。让线程运行。目的:将自定义代码存储在run方法。让线程运行。
c、调用线程的start方法,该方法两个作用:启动线程,调用run方法。
2、实现方式
创建线程的第二种方式:实现Runable接口
步骤:
a、定义类实现Runnable接口
b、覆盖Runnable接口中的run方法,将线程要运行的代码存放在该run方法中。
c、通过Thread类建立线程对象。
d、将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数。
为什么要将Runnable接口的子类对象传递给Thread的构造函数?
因为,自定义的run方法所属的对象是Runnable接口的子类对象。所以要让线程去指定指定对象的run方法。就必须明确该run方法所属对象。
e、调用Thread类的start方法开启线程并调用Runnable接口子类的run方法。
3、思考:
a,为什么要覆盖run方法呢?
:Thread类用于描述线程。该类就定义了一个功能,用于存储线程要运行的代码。该存储功能就是run方法。也就是说Thread类中的run方法,用于存储线程要运行的代码。
b,两种方式的区别?
实现方式好处:避免了单继承的局限性。
在定义线程时,建立使用实现方式。
两种方式区别:
继承Thread:线程代码存放Thread子类run方法中。
实现Runnable,线程代码存在接口的子类的run方法。
三、生命周期
1、图示
![](http://img.blog.csdn.net/20150222115940678?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvYXBwcm9jaGU=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center)
2、状态
创建:有两种创建方式,继承Thread和实现Runnable.
启动:调用start().
阻塞:调用sleep(...).
冻结:调用wait()和notify().
运行:启动后,获得执行权进入运行状态.
消亡:run方法体运行结束。
思考:
如何实现不同状态间的切换?
:线程一旦启动,就进入运行状态,有了执行资格,但能否得到执行权,则是随机的。我们所能控制的是线程的执行资格。
有两种方式可以操作执行资格:sleep函数定时阻塞和等待唤醒机制。
四、同步机制
1、同步的由来
多线程的运行出现了安全问题。
问题的原因:
当多条语句在操作同一个线程共享数据时,一个线程对多条语句只执行了一部分,还没有执行完,另一个线程参与进来执行。导致共享数据的错误。
解决办法:
对多条操作共享数据的语句,只能让一个线程都执行完。在执行过程中,其他线程不可以参与执行。
Java对于多线程的安全问题提供了专业的解决方式,即同步机制。
2、实现方式
同步函数:
同步的前提:
--1、必须要有两个或者两个以上的线程。
--2、必须是多个线程使用同一个锁。
必须保证同步中只能有一个线程在运行。
好处:解决了多线程的安全问题。
弊端:多个线程需要判断锁,较为消耗资源,
3、同步监视器
即指同步对象(锁)。同步函数用的是哪一个锁呢?函数需要被对象调用。那么函数都有一个所属对象引用。就是this。所以同步函数使用的锁是this。可以通过买票的事例验证。
同步代码块使用的是哪一个锁?可以自定义指定对象,当然尽量选择相关且有意义的对象。
静态同步函数用的是什么锁呢?静态的同步方法,使用的锁是该方法所在类的字节码文件对象。 类名.class。
4、死锁现象
同步中嵌套同步,容易引起死锁,应避免。比如:夫妻两人一人拿着大门钥匙,一人拿着保险柜的钥匙,无论哪个人都不能独立完成取钱的动作。
根本原因是存在着两把不同的锁。
5、新同步机制
1.5开始,java提供了新的同步实现方式,即引进了Lock和Condition这两个接口。Lock 替代了 synchronized 方法和语句的使用,Condition 替代了 Object 监视器方法的使用。
Lock 实现提供了比使用 synchronized 方法和语句可获得的更广泛的锁定操作。此实现允许更灵活的结构,性,可以支持多个相关的 Condition 对象。
Condition 实现可以提供不同于 Object 监视器方法的行为和语义,比如受保证的通知排序,或者在执行通知时不需要保持一个锁。
总结:
一个Lock对象可以配备多把锁,有效规避了同步嵌套造成死锁的问题。另外,因为在原同步基础上进行了对象封装,使用更加灵活,操作更加便捷。
思考:
同步函数与同步代码块的比较。
同步函数是对函数代码块的同步,同步代码块是对有线程安全问题的相关语句的同步。
五、多线程应用举例
1、单任务同步
2、多任务同步
多线程通信:多个线程执行多个任务(run函数)
3、集合的同步
表达不当之处,欢迎指正!
------Java培训、Android培训、iOS培训、.Net培训、期待与您交流! -------
一、基本概念
1、进程
2、线程 3、多线程(1)、优点(2)、缺点
4、思考:什么情况下,需要用到多线程?
二、创建方式
1、继承方式
2、实现方式 3、思考:两种方式的区别?
三、生命周期
1、图示
2、状态 思考:如何实现不同状态间的切换?
四、同步机制
1、同步的由来
2、实现方式 3、同步监视器
4、死锁现象 5、新同步机制
思考:同步函数与同步代码块的比较。
新同步机制的应用场景。
五、多线程应用举例
1、单事件同步
2、多事件同步 3、集合的同步
一、基本概念1、进程
是一个正在执行中的程序。每一个进程执行都有一个执行顺序。该顺序是一个执行路径,或者叫一个控制单元。
2、线程
就是进程中的一个独立的控制单元。线程在控制着进程的执行。
3、多线程
一个进程中至少有一个线程。Java VM 启动的时候会有一个进程java.exe.该进程中至少一个线程负责java程序的执行,而且这个线程运行的代码存在于main方法中,该线程称之为主线程。jvm启动不止一个线程,还有负责垃圾回收机制的线程。由此可知,Java VM就是一个多线程的程序。
1)优点
多条线程并发运行,提高了程序执行效率,充分发挥了人多力量大的优势;能够处理了单线程无法完成的工作。
2)缺点
多线程的运行并非所有线程同时运行,而是CPU在不同线程间做着高速的切换,这是由CPU的运行原理决定的。每个线程的运行却是独立的,那么,就有可能造成多个线程对同一数据的重复操作,这一现象称为线程安全问题。后面有详细描述。
4、思考:
什么情况下,需要用到多线程?
1、必须要分工协作才能完成事件;
2、可以明显提高效率,却不会影响到程序的正常运行。
多线程的特性?
独立、随机。
二、创建方式
1、继承方式
通过对api的查找,java已经提供了对线程这类事物的描述。就Thread类。
创建线程的第一种方式:继承Thread类。
步骤:
a、定义类继承Thread。
b、复写Thread类中的run方法。的:将自定义代码存储在run方法。让线程运行。目的:将自定义代码存储在run方法。让线程运行。
c、调用线程的start方法,该方法两个作用:启动线程,调用run方法。
2、实现方式
创建线程的第二种方式:实现Runable接口
步骤:
a、定义类实现Runnable接口
b、覆盖Runnable接口中的run方法,将线程要运行的代码存放在该run方法中。
c、通过Thread类建立线程对象。
d、将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数。
为什么要将Runnable接口的子类对象传递给Thread的构造函数?
因为,自定义的run方法所属的对象是Runnable接口的子类对象。所以要让线程去指定指定对象的run方法。就必须明确该run方法所属对象。
e、调用Thread类的start方法开启线程并调用Runnable接口子类的run方法。
3、思考:
a,为什么要覆盖run方法呢?
:Thread类用于描述线程。该类就定义了一个功能,用于存储线程要运行的代码。该存储功能就是run方法。也就是说Thread类中的run方法,用于存储线程要运行的代码。
b,两种方式的区别?
实现方式好处:避免了单继承的局限性。
在定义线程时,建立使用实现方式。
两种方式区别:
继承Thread:线程代码存放Thread子类run方法中。
实现Runnable,线程代码存在接口的子类的run方法。
三、生命周期
1、图示
2、状态
创建:有两种创建方式,继承Thread和实现Runnable.
启动:调用start().
阻塞:调用sleep(...).
冻结:调用wait()和notify().
运行:启动后,获得执行权进入运行状态.
消亡:run方法体运行结束。
思考:
如何实现不同状态间的切换?
:线程一旦启动,就进入运行状态,有了执行资格,但能否得到执行权,则是随机的。我们所能控制的是线程的执行资格。
有两种方式可以操作执行资格:sleep函数定时阻塞和等待唤醒机制。
四、同步机制
1、同步的由来
多线程的运行出现了安全问题。
问题的原因:
当多条语句在操作同一个线程共享数据时,一个线程对多条语句只执行了一部分,还没有执行完,另一个线程参与进来执行。导致共享数据的错误。
解决办法:
对多条操作共享数据的语句,只能让一个线程都执行完。在执行过程中,其他线程不可以参与执行。
Java对于多线程的安全问题提供了专业的解决方式,即同步机制。
2、实现方式
同步函数:
<span style="white-space:pre"> </span>public synchronized void Test(){}同步代码块:
<span style="white-space:pre"> </span>public void Test(){ <span style="white-space:pre"> </span>synchronized(对象) <span style="white-space:pre"> </span>{ <span style="white-space:pre"> </span>需要被同步的代码 <span style="white-space:pre"> </span>} <span style="white-space:pre"> </span>}对象如同锁。持有锁的线程可以在同步中执行。没有持有锁的线程即使获取cpu的执行权,也进不去,因为没有获取锁。经典举例---火车上的卫生间。
同步的前提:
--1、必须要有两个或者两个以上的线程。
--2、必须是多个线程使用同一个锁。
必须保证同步中只能有一个线程在运行。
好处:解决了多线程的安全问题。
弊端:多个线程需要判断锁,较为消耗资源,
3、同步监视器
即指同步对象(锁)。同步函数用的是哪一个锁呢?函数需要被对象调用。那么函数都有一个所属对象引用。就是this。所以同步函数使用的锁是this。可以通过买票的事例验证。
同步代码块使用的是哪一个锁?可以自定义指定对象,当然尽量选择相关且有意义的对象。
静态同步函数用的是什么锁呢?静态的同步方法,使用的锁是该方法所在类的字节码文件对象。 类名.class。
4、死锁现象
同步中嵌套同步,容易引起死锁,应避免。比如:夫妻两人一人拿着大门钥匙,一人拿着保险柜的钥匙,无论哪个人都不能独立完成取钱的动作。
根本原因是存在着两把不同的锁。
5、新同步机制
1.5开始,java提供了新的同步实现方式,即引进了Lock和Condition这两个接口。Lock 替代了 synchronized 方法和语句的使用,Condition 替代了 Object 监视器方法的使用。
Lock 实现提供了比使用 synchronized 方法和语句可获得的更广泛的锁定操作。此实现允许更灵活的结构,性,可以支持多个相关的 Condition 对象。
Condition 实现可以提供不同于 Object 监视器方法的行为和语义,比如受保证的通知排序,或者在执行通知时不需要保持一个锁。
总结:
一个Lock对象可以配备多把锁,有效规避了同步嵌套造成死锁的问题。另外,因为在原同步基础上进行了对象封装,使用更加灵活,操作更加便捷。
思考:
同步函数与同步代码块的比较。
同步函数是对函数代码块的同步,同步代码块是对有线程安全问题的相关语句的同步。
五、多线程应用举例
1、单任务同步
/* 买票案例:多个线程执行一个run方法 */ class Ticket implements Runnable { private int tick = 1000; Object obj = new Object(); public void run() { while(true) { synchronized(obj)//用同步代码块封装了两条以上的语句,保证数据的正确性。并指定了自定义的锁(obj) { if(tick>0) { try{Thread.sleep(10);}catch(Exception e){}//测试用 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(); } }
2、多任务同步
多线程通信:多个线程执行多个任务(run函数)
生产消费案例:多任务同步,并使用了新的同步机制完成。 import java.util.concurrent.locks.*; class ProducerConsumerDemo2 { public static void main(String[] args) { Resource r = new Resource(); Producer pro = new Producer(r); Consumer con = new Consumer(r); Thread t1 = new Thread(pro); Thread t2 = new Thread(pro); Thread t3 = new Thread(con); Thread t4 = new Thread(con); t1.start(); t2.start(); t3.start(); t4.start(); } } /* JDK1.5 中提供了多线程升级解决方案。 将同步Synchronized替换成现实Lock操作。 将Object中的wait,notify notifyAll,替换了Condition对象。 该对象可以Lock锁 进行获取。 该示例中,实现了本方只唤醒对方操作。 Lock:替代了Synchronized lock unlock newCondition() Condition:替代了Object wait notify notifyAll await(); signal(); signalAll(); */ class Resource { private String name; private int count = 1; private boolean flag = false; // t1 t2 private Lock lock = new ReentrantLock(); private Condition condition_pro = lock.newCondition(); private Condition condition_con = lock.newCondition(); public void set(String name)throws InterruptedException { lock.lock(); try { while(flag) condition_pro.await();//t1,t2 this.name = name+"--"+count++; System.out.println(Thread.currentThread().getName()+"...生产者.."+this.name); flag = true; condition_con.signal(); } finally { lock.unlock();//释放锁的动作一定要执行。 } } // t3 t4 public void out()throws InterruptedException { lock.lock(); try { while(!flag) condition_con.await(); System.out.println(Thread.currentThread().getName()+"...消费者........."+this.name); flag = false; condition_pro.signal(); } finally { lock.unlock(); } } } class Producer implements Runnable { private Resource res; Producer(Resource res) { this.res = res; } public void run() { while(true) { try { res.set("+商品+"); } catch (InterruptedException e) { } } } } class Consumer implements Runnable { private Resource res; Consumer(Resource res) { this.res = res; } public void run() { while(true) { try { res.out(); } catch (InterruptedException e) { } } } }
3、集合的同步
package replay; import java.util.ArrayList; import java.util.Collections; import java.util.List; import java.util.ListIterator; public class Test3 { /** * 请问怎么将线程不安全的集合转化为线程安全集合?请使用ArrayList作为例子体现。 */ public static void main(String[] args) { /*请问怎么将线程不安全的集合转化为线程安全集合? * 答: * 线程不安全,是指多线程并发运行引起的数据错乱问题。 * java中提供了解决线程不安全的方法,那就是同步机制。 * * 集合的线程安全是指,实现对集合中的同一元素的多个操作 * 的同步。 * * 在Collection工具类中,提供了处理不同集合线程 * 安全的方法,比如:实现List集合同步的方法, * public static <T> List<T> synchronizedList(List<T> list) * */ /* * 请使用ArrayList作为例子体现。 * 思路: * 1,获得线程安全的ArrayList对象list。 * 2,在该list中添加元素。 * 3,对list集合进行同步遍历。 * */ //1,获得线程安全的ArrayList对象list List<Person> list= Collections.synchronizedList(new ArrayList<Person>()); //2,添加元素 list.add(new Person("zhangsan", 23)); list.add(new Person("lisi", 24)); list.add(new Person("wangwu", 25)); list.add(new Person("zhaoliu", 26)); //3,同步遍历:把遍历代码封装在同步代码块中 synchronized (list) { ListIterator<Person> it=list.listIterator(); while(it.hasNext()) { Person p=it.next(); System.out.println(p); } } } } class Person { private String name; private int age; Person(String name,int age){ this.name=name; this.age=age; } public String toString(){ return "name="+name+",age="+age; } }4、懒汉式单例设计
/* 懒汉式单例模式 */ class Lazy { //对外只提供一个公有方法 private static Lazy l=null; private Lazy(){ System.out.println("lan han"); } public static Lazy getInstence() { //双重判断,在同一个app中,锁止判断一次 if(l==null) { synchronized(Lazy.class) { if(l==null) l=new Lazy(); } } return l; } }
表达不当之处,欢迎指正!
------Java培训、Android培训、iOS培训、.Net培训、期待与您交流! -------
相关文章推荐
- 黑马程序员_java基础加强8_多线程加强
- 黑马程序员---Java基础--11天(多线程)
- 黑马程序员---java基础之多线程
- 黑马程序员__JAVA基础__多线程
- 黑马程序员-Java基础之多线程总结
- 黑马程序员_java基础加强9_多线程加强
- [黑马程序员]--Java语言基础-多线程
- 黑马程序员-JAVA基础-多线程(上)
- 黑马程序员_Java多线程通信基础
- 黑马程序员---java基础多线程
- 黑马程序员—7、JAVA基础&多线程
- 黑马程序员-----java基础十二(java之多线程)
- 黑马程序员-Java语言基础– 多线程 第11天
- 黑马程序员-JAVA基础-多线程(下)
- 黑马程序员_java基础加强6_多线程加强
- 黑马程序员---------笔记整理(java基础八-----多线程)
- 黑马程序员_Java基础_多线程1
- 黑马程序员_Java基础(4)--多线程
- 黑马程序员 java基础之多线程
- 黑马程序员 Java基础 --->多线程