黑马程序员_java入门_多线程
------- android培训、java培训、期待与您交流！ ----------
一概念
进程：一个正在的执行的程序
线程：一个程序进程中的控制单元
一个进程至少有一个线程。
二，多线程
1.定义一个类，继承Thread
2.复写里面的run（）方法
3.建立对象后用start（）方法运行
start方法的两个作用
1.启动线程
2.运行run（）方法
sleep（）和wait（）的区别
sleep()是一种临时阻塞，里面填上时间后，时间结束就能再次启动，同时判断有没有执行权
wait（()是一种唤醒机制，需要使用一个notify再能叫醒，不具有定时性
三。获取多线程的名称
Thread.currentThread()//返回一个对象 类名。方法名 因为静态的可以直接调用
获取线程名称
Thread.currentThread().getName()
四.实现多线程的第二种方法
1.定义类实现Runnable接口
2.复习Runnable方法里面的run()方法
3.通过Thread类建立线程对象
4.将Runnable接口的子对象作为实际参数传递给Thread类的构造函数
5.建立了一个Thread类
6.调用start（）方法开启线程
实现方式和继承方式的区别
实现方式避免了单继承的局限性，建议使用实现方式
1.一个继承
2.一个实现
五.多线程的安全问题
问题:一个线程还没执行完，另一线程有参与了进来，导致属于错乱
解决办法，加一个锁，防止后面进程进来
同步代码块
synchronized（对象）
{
需要被同步的代码
}
六.同步代码块
同步的前提
1.必须有两个或两个以上的线程
2.必须是多个线程使用同一个所
好处：1.解决了安全问题
弊端：消耗了锁的资源
同步函数用的锁一般是this锁，this.class是一个字节码文件，也是一个对象，就是建立对象后的this
静态同步函数
如果一个函数被静态后，那么他的锁不是this锁了，而是类名.class锁
七单例设计模式---懒汉式
class SingleDemo
{
private static SingleDemo s=null;
private SingelDemo(){}
public static SingleDemo getSingle(){
if(s==null){
suychronized(SingelDemo.class)
{
if(s==null)
{
s=new SingleDemo();
}
}
return s;
}
}
八。死锁
锁的互相调用，容易导致死锁，经量避免
九.多线程的等待唤醒机制
wait（）
notify()
notifyAll（）
用了什么锁，就要用什么锁来唤醒
r.notify();
}
十。jdk新特性
Lock unLock
class Resource//多个生产者 多个消费者
{
privater String name;
private int count=1;
private boolean flag=false;
private Lock lock=new RenntrantLock();
private Condition condition_pro=lock.newCondition();
private Condition condition_con=lock.newCondition();
public void set(String name) throws InterruptedException
{
lock.lock();//锁中有标记，一个锁多个condition
try{
while(flag)
condition_pro.await();//抛异常。没处理。声明出去
this.name=name+"---"+count++;
sop(Thread.currenThread().getNname()+"生产者"+this.name);
flag=true;
condition_con.signal();
}
finnaly
{
lock.unlock();
}
}
public void out() throws InterruptedException
{
``` lock.lock();
try{
while(!flag)
condition_con.await();
sop("消费者")；
flag=false;
condition_pro.signal();
}
finnally
{
lock.unlock();
}
}
}
class Producer implements Runnable
{
private Resource res;
Produce(Resource res)
{
this.res=res;
}
public void run()
{
while(true)
{
try
{
res.set("商品")；
}
catch(InterruptedException e)
{
}
}
}
}
class Comsumer implements Runnable
{
private Resource res;
Comsumer(Resource res)
{
this.res=res;
}
public void run()
{
while(true)
{
try
{
res.out()；
}
catch(InterruptedException e)
{
}
}
}
}
class Demo
{
public static void main(String[] args)
{
Resource r=new Resource;
Producer P=new Producer(r);
Comsumer c=new Comsumer(r);
p.start();
c.start();
}
}
十一.停止线程
线程.interruput()
十二、守护线程
t1.setDemo（true）；
主线程一结束，后面的线程自动结束（指的是守护线程）
join（）抢夺主线程执行权
，等待抢劫者执行完，主线程才执行
十三线程的优先级
t1.setPriority（Thread.MAX_PRIORITY）
线程的优先执行
Thread.yield()临时释放，可以使程序交替执行。。