黑马程序员_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()临时释放，可以使程序交替执行。。