Java线程总结（一）

Java线程总结（一）

1.线程的生命周期

1）创建(3种方式)

a.继承Thread类

public class ThreadDemo1 extends Thread{
		@Override
		public void run() {
			for(int i=0;i<10;i++) {
				System.out.println(i);
			}
		}
	}

b.实现Runnable接口

public class ThreadDemo2 implements Runnable {
		@Override
		public void run() {
			for(int i=0;i<10;i++) {
				System.out.println(i);
			}
		}
	}

c.实现Callable接口

public class ThreadDemo3 implements Callable<Integer>{
		@Override
		public Integer call() throws Exception {
			int s=0;
			for(int i=0;i<10;i++) {
				s+=i;
			}
			return s;
		}
		
	}

首先a和b需要重写run（）方法且没有返回值，而c需要重写call方法，且带有返回值。

a通过继承Thread类实现，而b和c均是通过接口实现，通过接口的话可扩展性较强，可以实现多个接口，完成更加复杂的功能。

2）就绪（.start()方法）

public static void main(String[] args) {
		Thread t =new Thread();
		t.start();
	}

创建线程对象，调用start方法进入就绪，随后会执行run（）方法启动线程

3）运行（.run()方法）

4）阻塞（.block()方法）

sleep()

public static class SleepThread extends Thread{
		@Override
		public void run() {
			for(int i=0;i<10;i++) {
				System.out.println(currentThread().getName()+":"+i);
				try {
					sleep(200);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}
	}

让当前执行的线程暂停执行，让其他线程有机会执行。也可以让同优先级、高优先级的线程有执行的机会。

yield()

public static class YieldThread extends Thread{
		@Override
		public void run() {
			for(int i=0;i<10;i++) {
				if(i==4) {
					Thread.yield();
				}
				System.out.println(currentThread().getName()+":"+i);
			}
		}
	}

该方法与sleep()类似，只是不能由用户指定暂停多长时间，并且yield（）方法只能让同优先级的线程有执行的机会。

join()

public static class JoinThread extends Thread{
		@Override
		public void run() {
			for(int i=0;i<10;i++) {
				
				System.out.println(currentThread().getName()+":"+i);
			}
		}
	}

join()方法使调用该方法的线程在此之前执行完毕，也就是等待该方法的线程执行完毕后再往下继续执行。

wait()

wait()方法使当前线程暂停执行并释放对象锁标示，让其他线程可以进入synchronized数据块，当前线程被放入对象等待池中

5）死亡（自然死亡）

2.java线程内存模型（CAS（ABA））

java的线程中包括有一个工作内存，工作内存会将主存当中的变量读取并保存到工作内存当中进行操作，并且是每个线程所私有的，不能被其他线程访问。

工作流程：

1.从主存中拷贝到当前内存

2.执行代码改变变量

3.用工作内存刷新相关的主内存（CAS：campare and swap）

通过比较主内存和工作内存的值来判断，如果不一致则会更新数据。

此时就会发生一个新的问题（ABA）：首先将数据A通过B手段改动之后又会变回A，此时的数据值虽然没有改变，但是本质却发生改变。

解决方法：给原先主内存的数据加上版本号，执行操作过后先比较版本号之后再比较数值

3.线程的三大特性

关键字volatile：

volatile 关键字就是用于保证内存可见性，当线程A更新了volatile修饰的变量时，它会立即刷新到主内存中，并且将其余缓存中该变量的值清空，导致其余线程只能去主内存读取最新值。使用 volatile关键词修饰的变量每次读取都会得到最新的数据，不管哪个线程对这个变量的修改都会立即刷新到主内存。

1）可见性

当多个线程同时访问一个变量时，一个线程修改了这个变量的值，其它线程能立即看得到它修改的值

public class ThreadSecurity {
	static  boolean flag=false;
	public static void main(String[] args) throws Exception {
		Thread t1=new ThreadA();
		Thread t2=new ThreadB();
		t1.start();
		Thread.sleep(1000);
		t2.start();

	}
	public static class ThreadA extends Thread{
		@Override
		public void run() {
			while(true) {
				if(flag) {
					System.out.println("A:"+flag);
					try {
						sleep(100);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					break;
				}			
			}
		}
	}
	public static class ThreadB extends Thread{
		@Override
		public void run() {
			flag=true;
			
				System.out.println("B:"+flag);
				try {
					Thread.sleep(100);
				} catch (InterruptedException e) {		
					e.printStackTrace();
				}
		}
	}
	
}

没有添加关键字volatile时运行结果只有线程B启动，因为A线程并不知道flag变为true，依旧保留原先的fasle，但是在flag之前加上关键字，结果两个线程都启动了，保证了flag的可见性。

2）有序性

在Java内存模型中，允许编译器和处理器对指令进行重排序，但是重排序过程不会影响到单线程程序的执行，却会影响到多线程并发执行的正确性

使用关键字volatile可以解决有序性的问题

3）原子性

和数据库事务的原子性差不多，即一个操作或者多个操作，要么全部执行并且执行的过程不会被任何因素打断，要么就都不执行。在JAVA中，对基本数据类型的变量的读取和赋值操作是原子性操作，即这些操作是不可被中断的，要么执行，要么不执行。即一个操作或多个操作要么全部执行并且执行过程中不被任何因素打断，要么就不执行。

public class ThreadAtomicDemo {
	static volatile AtomicInteger x=new AtomicInteger(0);

	public static void main(String[] args) {
		Thread t1=new AtomicThread();
		Thread t2=new AtomicThread();
		Thread t3=new AtomicThread();
		
		t1.start();
		t2.start();
		t3.start();

	}
	
	public static class AtomicThread extends Thread{
		@Override
		public void run() {
			for(int i=0;i<100;i++) {
				System.out.println("当前x:"+(x.incrementAndGet()));
				try {
					sleep(200);
				} catch (InterruptedException e) {
					
					e.printStackTrace();
				}
			}
		}
	}

}

若不使用Atomic包的话，最后不会到达300，使用后程序能够正常运行到300，保证了线程安全

4.形成死锁的四个必要条件

synchronized：又称为：同步锁

a.当两个线程并发访问同一对象中的synchronized(this)代码块时，一个时间内只能有一个线程得到执行。另外一个线程必须等待当前线程执行完这个代码块以后才能执行该代码

b.当一个线程访问对象的synchronized代码块时，另外一个线程仍然能访问非synchronized 修饰的代码块。

c.当一个线程访问到synchronized代码块时，其它线程对对象中所有的其它synchronized同步代码块访问被阻塞。

d.同一时间只有一个线程能够取得对象的锁。

public synchronized test(){}//锁住方法
public void test(){
  synchronized(this){}//锁住方法中某一句
}

1）互斥使用

2）不可抢占

3）请求和保持

4）循环等待

循环等待死锁实现：

public class DeadLockDemo {

	public static void main(String[] args) {
		DeadLock a = new DeadLock("A");
		DeadLock b = new DeadLock("B");
		DeadLock c = new DeadLock("C");
		DeadLockThread t1 = new DeadLockThread(a, b, c);
		DeadLockThread t2 = new DeadLockThread(b, c, a);
		DeadLockThread t3 = new DeadLockThread(c, a, b);
		t1.start();
		t2.start();
		t3.start();
	}

	public static class DeadLock {
		private String name;

		public DeadLock(String name) {
			this.name = name;
		}

		public String getName() {
			return name;
		}

	}

	public static class DeadLockThread extends Thread {
		private DeadLock a;
		private DeadLock b;
		private DeadLock c;

		public DeadLockThread(DeadLock a, DeadLock b, DeadLock c) {
			this.a = a;
			this.b = b;
			this.c = c;
		}

		@Override
		public void run() {
			synchronized (a) {
				System.out.println("锁住" + a.getName() + "成功");
				System.out.println("准备锁住" + b.getName());
				synchronized (b) {
					System.out.println("锁住" + b.getName() + "成功");
					System.out.println("准备锁住" + c.getName());
					synchronized (c) {
						System.out.println("锁住" + c.getName() + "成功");
					}
					System.out.println("释放" + c.getName() + "成功");
				}
				System.out.println("释放" + b.getName() + "成功");
			}
			System.out.println("释放" + a.getName() + "成功");
		}
	}

}

最后形成死锁，程序一直无法终止。