线程机制

1.线程的创建和启动

线程的创建有两种方式，分别是继承Thread类和继承Runnable接口。

1.1 继承Thread类

当一个类需要按照多线程的方式处理时，只需继承Thread即可，并且还要覆盖该类的run()方法，run()方法作为线程的主体。启动一个线程使用start()方法。

通常情况下，实现一个线程并不会特意新建一个类，而是采用内部类的方式创建，或者采用类似于匿名内部类的方式创建。

下面是三种实现线程的写法：

public class Test {
	public static void main(String[] args) {
		//1
		Test2 t2 = new Test2();
		t2.start();
		//2
		Test.Test3 t3 = new Test().new Test3();
		t3.start();
		//3
		Thread t = new Thread(){
			@Override
			public void run() {
				System.out.println("ttt");
			}
		};
		t.start();
	}
	class Test3 extends Thread{
		@Override
		public void run() {
			System.out.println("test3");
		}
	}
}
class Test2 extends Thread{
	@Override
	public void run() {
		for (int i = 0; i < 5; i++) {
			System.out.println(i);
		}
	}
}

1.2 实现Runnable接口

在实现Runnable接口的线程，启动时，首先创建一个Thread对象，并将实现Runnable接口类的实例放入Thread的构造器中。

public class Runnable1 {
	public static void main(String[] args) {
		//第一种
		Runnable1.Runnable2 r2 = new Runnable1().new Runnable2();
		Thread t2 = new Thread(r2);
		t2.start();
		//第二种
		Runnable r = new Runnable() {
			
			@Override
			public void run() {
				System.out.println("Runnable");
			}
		};
		Thread t = new Thread(r);
		t.start();
		//第二种可以简写为
		new Thread(new Runnable() {
			
			@Override
			public void run() {
				System.out.println("Runnable3");
			}
		}).start();
	}
	class Runnable2 implements Runnable{

		@Override
		public void run() {
			System.out.println("Runnable2");
			
		}
		
	}
}

1.3 继承Thread类 和 实现Runable接口 两种方式创建线程的区别

• 继承的局限性：知道Java是单继承的，一旦继承Thread将无法继承其他类。
• 资源共享问题：使用Runnable接口可以实现资源（对象属性）共享，而Thread类却无法 

public class Thread_Runnable {
	public static void main(String[] args) {
		//开启三个线程
		Thread_Runnable.Thread1 t1 = new Thread_Runnable().new Thread1();
		Thread_Runnable.Thread1 t2 = new Thread_Runnable().new Thread1();
		Thread_Runnable.Thread1 t3 = new Thread_Runnable().new Thread1();
		t1.start();
		t2.start();
		t3.start();
	}
	class Thread1 extends Thread{
		private int count =3;
		@Override
		public void run() {
			for (int i = 0; i < 20; i++) {
				if (count>0) {
					System.out.println("count="+count--);
				}
			}
		}
	}
}

上面一段代码运行后结果是：

count=3
count=2
count=1
count=3
count=2
count=1
count=3
count=2
count=1

由此可以看出Thread是资源不贡献的

public class Thread_Runnable {
	public static void main(String[] args) {
		//开启三个线程
		Thread_Runnable.Runable1 r1 = new Thread_Runnable().new Runable1();
		Thread thread1 = new Thread(r1);
		Thread thread2 = new Thread(r1);
		Thread thread3 = new Thread(r1);
		thread1.start();
		thread2.start();
		thread3.start();
	}
	class Runable1 implements Runnable{
		private int count=3;
		@Override
		public void run() {
			for (int i = 0; i < 20; i++) {
				if (count>0) {
					System.out.println("count="+count--);
				}
			}
		}
		
	}
}

这段代码运行结果是：

count=3
count=1
count=2

由此可以看出Runnable方式的线程，可以实现资源共享

2. 线程组

在Java中所有的线程都属于一个线程组，这个线程组可以是默认的，也可以是自己创建的。在创建时，线程被限制到一个组里，而且不能改变到其他组，而线程组也必须从属 与其他组。简单的说，线程组（ThreadGroup）就是由线程组成的管理线程的类，这个类使Java.lang.ThreadGroup类。

下面代码可以实现定义一个线程组

		ThreadGroup group = new ThreadGroup("group");
		Thread thread = new Thread(group,"-----");

3. 线程状态

每个线程都有生命周期，就像每个人都会有生老病死。

3.1 线程状态

从该图可以大致将线程分为五种状态：

1. 初始：当创建一个线程时。
2. 可执行：调用了start()方法。
3. 运行：调用了run()方法。
4. 停止：因为所以的线程都需要枪占CPU的资源，当一个线程交出资源时，就会留给其他线程继续执行。
5. 死亡：当所以的线程运行结束后，就会中止，然后进入死亡状态。

3.2 线程状态装换

3.2.1  线程名字的取得和设置

public class Thread_Runnable {
	public static void main(String[] args) {
		//开启三个线程
		Thread_Runnable.Thread1 t1 = new Thread_Runnable().new Thread1();
		Thread_Runnable.Thread1 t2 = new Thread_Runnable().new Thread1();
		Thread_Runnable.Thread1 t3 = new Thread_Runnable().new Thread1();
		t1.setName("线程1");//设置线程名称
		t1.start();
		t2.start();
		t3.start();
		//开启三个线程
		Thread_Runnable.Runable1 r1 = new Thread_Runnable().new Runable1();
		Thread thread1 = new Thread(r1);
		Thread thread2 = new Thread(r1);
		Thread thread3 = new Thread(r1);
		thread1.setName("线程4");
		thread1.start();
		thread2.start();
		thread3.start();
		ThreadGroup group = new ThreadGroup("group");
		Thread thread = new Thread(group,"-----");
	}
	class Thread1 extends Thread{
		@Override
		public void run() {
			System.out.println("Thread当前线程的名称为："+Thread.currentThread().getName());
		}
	}
	class Runable1 implements Runnable{
		@Override
		public void run() {
			System.out.println("当前线程的名称为："+Thread.currentThread().getName());
		}
		
	}
}

Thread当前线程的名称为：线程1
Thread当前线程的名称为：Thread-1
Thread当前线程的名称为：Thread-2
当前线程的名称为：线程4
当前线程的名称为：Thread-5
当前线程的名称为：Thread-4

3.2.2 线程的休眠

		public void run() {
			try {
				//单位是毫秒，1000就是线程休息一秒
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				// TODO 自动生成的 catch 块
				e.printStackTrace();
			}
		}

3.3 让线程间通信

3.3.1同步  使用Synchronized关键字

同步的概念：也就是给方法加锁，当其他线程调用该方法，如果锁解开了才能调用，如果没有，则不能调用。使用Synchronized关键字。

同步就相当于排队上公交车，大家都是有顺序的，只有等前一个人上了车之后，下一个才能上车。

同步有两种方式：1.使用synchronized 包裹，2.在方法中直接加上synchronized关键字，作用和synchronized代码块中加上this效果相同。

但是在方法中直接加上synchronized关键字又要注意一点，如果两个方法都是非静态的，可以实现同步，但是如果其中一个是静态方法就会不同步。这是因为静态方法是所属这个类的，并不是该类的某一个对象。因此锁住的不应该是该类的对象，而是类的字节码，因为类的字节码永远只有一份。

3.3.2 异步

异步就会出现前面个线程调用都还没有执行完，下一个线程就也调用了，这时就会放弃前面个调用执行后面个。

3.3.3 JDK1.5提供新的锁机制

Lock接口：Lock实现提供了比使用Synchronized方法和语句可获得更广泛的锁定操作，此实现允许更灵活的结构。

读锁：ReentrantReadWriteLock.ReadLock  写锁：ReentrantReadWriteLock.writeLock

ReadWriteLock rwl = new ReentrantReadWriteLock();
rwl.readLock().lock();//读锁
rwl.readLock().unlock();//解读锁

rwl.writeLock().lock();//写锁
rwl.writeLock().unlock();//解写锁

Lock lock = new ReentrantLock();
加锁：lock.lock();     解锁：lock.unlock();

为防止如果发生异常，将不能解锁的情况发生，所以应该将代码块放在try当中，在finally当中解锁。

JDK1.5还提供了 ThreadLocal类，其实该累的底层就是通过类似于Map的手法完成的，该类的set和get分别为存数据和取数据。

ThreadLocal<Integer> local = new ThreadLocal<Integer>();
local.get();
local.set(数据/对象);

  JDK1.5提供了线程池，可以规定线程的个数，当线程的个数超过设置的个数时，就需要在外面等，知道有其他线程主动让开才行，这样就避免了服务器的压力。

Java.util.concurrent包下得ExecutorService可以设置线程的个数。实例化：

xecutorService pool = Executors.newFixedThreadPool(线程个数);
pool.execute(new 线程);

3.3.4 等待和唤醒

等待和唤醒分别对应的是wait和notify方法，这两个方法必须要在有锁的方法中才生效，否则会报异常。当前线程必须拥有此对象监视器，该线程发布对此监视器的所有权并等待，知道其他线程通过调用notify方法，或notifyAll方法通知在此对象的监视器上等待线程醒来。然后该线程将等到重新获得对监视器的所有权后才能继续执行。对于某一个参数的版本，实现中断和虚假唤醒是可能的，而且此方法应始终在循环中使用

。

在jdk1.5中的Java.util.concurrent.lcks包下得Condition类位提供了类似的方法，该类中的await()方法对应的就是wait()方法，signal()方法对应的就是notify()方法。

3.3.5 死锁

死锁情况就是：多个线程同时被阻塞，它们中的一个或全部都在等待某个资源被释放，由于线程被无限期的阻塞，因此，程序不能正常运行。导致死锁的根源在于不恰当的运用“synchronize”来管理线程。

3.3.6 常用的线程集合类

ConcurrentHashMap-------HashMap的线程安全类

CopyOnWriteArrayList------ArrayList的线程安全类

CopyOnWriteArraySet------Set的线程安全类

3.3.6守护线程

Java中的守护线程也称为后台线程或精灵线程，作用是当所有前台线程运行完，不管后台线程有没有结束，守护线程都必须停止。

守护线程的写法：调用线程对象的方法setDaemon(true)。就可以就其设置为守护线程。