------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、可以明显提高效率，却不会影响到程序的正常运行。
多线程的特性？
独立、随机。
通过对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;4、懒汉式单例设计
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;
}
}
/*
懒汉式单例模式
*/
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培训、期待与您交流！ -------