多线程

 

多线程：
	进程：正在进行中的程序。
	线程：进程中一个控制单元。
	一个进程最少有一个线程。

	当有多个线程时，可以提高运行效率。如：下载工具。

	特性：随机性。

	什么时候使用多线程呢？
	当多部分程序需要同时运行时，就要使用多线程来解决。


	线程创建的方式：
	通过Thread类对线程进行描述。
	所以只要创建Thread类的对象即可创建控制单元。
	但是如何让创建的控制单元来运行我们指定的代码呢？

	为了让创建的控制单元和自定义的线程运行代码有关联。
	Thread类提供了一个存放线程代码的位置-run().

	方式一：继承Thread类。
	只要通过定义Thread类的子类，并覆盖run方法即可让线程代码存入run方法中。
	通过调用Thread类中的start方法开启线程并执行run方法。

	class SubThread extends Thread
	{
		public void run()
		{}
	}
	main()
	{
		SubThread s = new SubThread();
		s.start();
		//s.run();
	}

	方式二：实现Runnable接口
	定义一个类实现Runnable接口并覆盖run方法。
	通过Thread类创建线程对象，将Runnable接口的子类对象作为参数传递给Thread类的构造函数。

	将自定义的run方法所属的对象作为参数传递给Thread类的构造函数，就是为了让线程执行自定义的run方法。
	通常情况下，用这种方式较多，为什么呢？因为实现Runnable接口，避免了单继承的局限性。

	class RunImpl implements Runnable
	{
		public void run()
		{}
	}

	main()
	{
		RunImpl r = new RunImpl();
		Thread t = new Thread(r);
		t.start();

	}
		

	class Demo extends Test implements Runnable
	{
		public void run(){code...}
	}


	-------------------------

	class Demo extends Thread 
	{
		private String name;
		Demo(String name)
		{
			this.name = name;
		}
		public void run()
		{
			for(int x=0; x<10; x++)
			{
				for(int y=-99999; y<99999999; y++){}
				System.out.println(Thread.currentThread().getName()+"....name="+name);
			}
		}
	}

	main()
	{
		Demo d1 = new Demo("one");
		Demo d2 = new Demo("two");
		//d1.run();
		//d2.run();
		d1.start();
		d2.start();
	}

多线程：
	创建方式
	1）继承Thread类。
	2）实现Runnable接口。避免了单继承的局限性。

	因为多线程具备一个随机性，就会容易出现线程安全问题。
	导致该问题的原因通常是：多条语句同时在操作成员数据，这是这些语句被多个线程分开执行，就会出现安全问题。

	解决方式：
	将多条语句在同一时间被一个线程一次执行完，在让另一个线程执行。
	通过同步代码块来完成部分代码的同步。synchronized(对象){}

	同步的出现
	好处：解决了多线程安全问题。
	弊端：对资源有一定消耗，降低了程序的效率。
	      如果同步出现嵌套还容易引起死锁。
		
	死锁示例：
		class Lock
		{
			static Lock a = new Lock();
			static Lock b = new Lock();
		}

		class Demo implements Runnable
		{
			private boolean b;
			private Lock l;
			Demo(boolean b)
			{
				this.b = b;
			}
			public void run()
			{
				if(b)
				{
					synchronized(Lock.a)
					{
						System.out.println("a lock");
						synchronized(Lock.b)
						{
							System.out.println("b lock");
						}
					}
				
				}
				else
				{
					synchronized(Lock.b)
					{
						System.out.println("b lock");
						synchronized(Lock.a)
						{
							System.out.println("a lock");
						}
					}
				}
			}
		}
		
		class DeadLock
		{
			public static void main(String[] args)
			{
				Demo d1 = new Demo(true);
				Demo d2 = new Demo(false);
				Thread t1 = new Thread(d1);
				Thread t2 = new Thread(d2);
				t1.start();
				t2.start();
			}
		}

	同步的表现形式：
		1，同步代码块。锁可以自定义。
		2，同步函数，所使用的锁是this。
			特例：当同步函数被静态修饰时，所使用的锁是  类名.class
		参阅day11\ThisLock.java

	
	在单例设计模式中的懒汉式：
	class Single
	{
		private static Single s = null;
		private Single(){}
		public static synchronized Single getSingle()
		{
			if(s==null)

				s = new Single();
			return s;
		}
	}
	这种方式，如果被多线程并发访问获取对象时，容易出现安全隐患。
	会在getSingle函数上加上同步关键字。
	虽然安全性提高了，但是效率却降低了。

	同步函数所使用的锁是哪一个呢？Single.class


	线程间通讯：
	多个线程操作同一个资源，但是操作的动作却是不同的。
	毫无疑问，每一个程序运行的代码是不一样的，所以分别定义run方法，并存放在不同的类中。
	参阅day11\CommDemo2.java

	wait(),notify(),notifyAll().
	wait():可以让线程进入到冻结状态，如果没有指定时间，那么必须要通过notify唤醒。
	notify():唤醒被wait的线程，通常唤醒线程池中的第一个。
	notifyAll();唤醒线程池中的所有。

	这些方法为什么定义在Object类中。
	因为这些方法都要定义在同步中，因为同步有可能出现嵌套，那么必须要明确该方法所属的锁。
	而锁可以是任意对象，能被任意对象都调用的方法，一定定义在Object类中。

	sleep(),wait()的区别：
	sleep():释放资源，不释放锁。
	wait():释放资源，释放锁。

	因为stop方式已经过时，那么如何停止线程呢？
	原理：通过run方法结束，线程没有了要运行的代码，自动结束。
		而run方法中，通常都会定义循环语句，那么只要控制住循环即可。

	1，定义结束标记。
		但这种情况，如果遇到了可以将线程进行冻结的方法，那么是读不到结束标记的。
	2，使用Thread中的interrupt方法.
		中断线程：意为清除线程的冻结状体，强制让线程回复到运行状态中来。

	有哪些方式可以让线程进入到冻结状体呢：
	wait(),sleep(),join().

	join():临时加入一个线程，并将该线程执行结束。
	
	setDaemon(true):将线程标记为守护线程(后台线程)，该线程和前台线程一样开启，并抢资源运行，但是结束有所不同，
	当所有前台线程都结束后，后台线程自动结束。圣斗士星矢。

	线程的优先级：1~10
	通过三个名称来标识一下区别最大的三个优先级。
	MAX_PRIORITY MIN_PRIORITY NORM_PRIORITY

	yeild():对线程进行临时暂停，为了稍微减缓线程运行的速度。