黑马程序员_多线程知识总结



------------------------------------------------android培训、java培训、期待与您交流！-----------------------------------------------

❶进程和线程的区别

①调度
同一进程中线程的切换不会引起进程的切换，线程作为调度和分派的
基本单位，从一个进程的线程切换到另一个进程的线程中会引起进程切换
②资源
进程作为资源拥有的基本单位,线程自己不拥有系统资源，
但它可以访问其隶属进程的资源
③系统开销
进程切换会涉及当前进程CPU的保存和相关的环境设置比较耗资源
而线程切换则仅需保存和设置少量寄存器的内容，
④隶属关系
一个进程可以有多个线程，并且各个线程都可以访问该进程所拥有的资源

❷线程的生命周期

❸创建多线程的两种方式

①继承Thread类

线程代码存放Thread子类run方法中

②实现Runnable接口

线程代码存在接口的子类的run方法

③这二者之间的比较

建议用Runnable接口实现，第一在于避免了单继承的局限性，第二在于实现的方式可以实现资源和代码的共享。

❺多线程意义及安全问题

①多线程的意义
因为CPU在某一个时刻只执行一个程序，它是按照时间切换的方式运行程序，为了提高CPU的使用率，
采用多线程的方式去同时完成几件事情而互不干扰

②出现问题的原因

当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完，
 另一个线程参与进来执行,导致共享数据的错误

③解决办法

采用同步的机制

❻Java中的同步

①同步的分类

ⓐ代码块的同步
可以用任意对象作为其同步锁
ⓑ函数的同步
其同步锁是this
ⓒ静态函数的同步
其同步锁是所在类的类名.class

②同步的前提
必须要有两个或者两个以上的线程。
必须是多个线程使用同一个锁。
必须保证同步中只能有一个线程在运行。

❼由单例模式引出的重点

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;
	}
}

①该单例模式可以延迟加载
②如果不加锁多线程访问会出现安全问题
③用双重判断的方式可以解决加锁引起判断锁带来的低效问题
④该同步使用的锁为Single.class(类名.class)

❽死锁的一个例子

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();
	}
}

❾线程的通信

①本质

多个线程在操作同一个资源，只是操作的动作不同

②锁对象里面的方法

wait的线程都放在一个线程池里面
notify唤醒线程就是从线程池里面唤醒线程
notifyAll唤醒所有的线程
等待和唤醒必须是同一个锁，Wait 只能唤醒同一个锁的notify
哪个对象调用的wait方法使得该线程等待只有用该对象才能唤醒相应的线程

③新的锁对象

将同步Synchronized替换成现实Lock操作。
将Object中的wait，notify notifyAll，替换成了Condition对象

该对象有一个很好的好处就是实现了本方只唤醒对方操作

④为什么wait和notify方法要定义在Object上

因为锁是任意的对象，可以被任意对象调用的那么就只有Object了

⑤生成者和消费者的一个例子

class Resource
{
	private String name;
	private int count = 1;
	private boolean flag = false;
	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();
			this.name = name + "--" + count++;
			System.out.println(Thread.currentThread().getName()+ "...生产者.." + this.name);
			flag = true;
			condition_con.signal();
		} finally
		{
			lock.unlock();// 释放锁的动作一定要执行。
		}
	}
	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)
			{
			}
		}
	}
}

❿线程中的一些方法

①停止方法

用一个标记来控制线程的停止while(flag)

②setDeaemon守护线程
前台线程(主)结束之后它后面的线程(子线程)也会结束
也就是说同生死共患难那种

③join方法
当这个线程运行完之后再交出CPU执行权
运行结果：t1线程和t2线程轮流执行(由于t1和t2都获得了执行权)，但是主线程要等t1执行完之后才执行
public static void main(String[] args)
{
    Thread t1 = new Thread(d);
    Thread t2 = new Thread(d);
    t1.start();
    t2.start();
    t1.join();
    System.out.println("over");
}

④yield方法
暂时释放CPU执行权，可以使得多个线程都可以得到执行机会

class Demo implements Runnable
{
	public void run()
	{
		for(int x=0; x<70; x++)
		{
			System.out.println(Thread.currentThread().toString()+"....."+x);
			Thread.yield();//如果不用yield的话可能某一个线程要打印好几次，用之后可以一个来一次，实现平均
		}
	}
}
class  Demo
{
	public static void main(String[] args) throws Exception
	{
		Demo d = new Demo();
		Thread t1 = new Thread(d);
		Thread t2 = new Thread(d);
		t1.start();		
		t2.start();		
		System.out.println("over");
	}
}

⑤interrupt方法的作用

在线程受到阻塞时抛出一个中断信号，这样线程就得以退出阻塞的状态。更确切的说，如果线程被Object.wait, Thread.join和Thread.sleep三种方法之一阻塞，那么，它将接收到一个中断异常（InterruptedException），从而提早地终结被阻塞状态

class StopThread implements Runnable
{
	private boolean flag =true;
	public  void run()
	{
		while(flag)
		{
			try
			{
			      wait();
			}catch(InterruptedException e)
			{
			System.out.println(Thread.currentThread().getName()+"....exception");
			}
			System.out.println(Thread.currentThread().getName()+"....run");
		}
	}
	public void changeFlag()
	{
		flag = false;
	}
}
class  StopThreadDemo
{
	public static void main(String[] args) 
	{
		StopThread st = new StopThread();
		
		Thread t1 = new Thread(st);
		Thread t2 = new Thread(st);
		t1.start();
		t2.start();
		int num = 0;
		while(true)
		{
			if(num++ == 60)
			{
				t1.interrupt();
				t2.interrupt();
				break;
			}
			System.out.println(Thread.currentThread().getName()+"......."+num);
		}
		System.out.println("over");
	}
}

-----------------------------------------android培训、java培训、java学习型技术博客、期待与您交流！ --------------------------

详情请查看：http://edu.csdn.net/heima