java并发线程---线程的一些概念

在上一篇的博文里面，我简单的介绍了一下，怎么去创建一个线程，有哪些方法来实现一些线程的使用，

        没看过的话可以看看（点击打开链接），里面也有一些需要注意的地方，比如volatile关键字的使用。

为了更好的理解多线程，我想我们必须要清楚的明白线程的状态：（有5种）

（1）new状态          ------------ 通过new 关键字新建一个线程。

（2）Runnable状态----------- 就绪状态

（3）Running 状态 ----------- 正在运行

（4）Blocked状态   ------------ 阻塞状态（这里要明白常见的三种，下面我详细的说说）

（5）Dead 状态    --------------死亡状态。就是执行完成一个run方法或者是遇到了一些异常。

造成线程Blocked阻塞状态的常见的3种原因：

（1）等待阻塞：线程执行了wait()方法，此刻线程会挂起，等待被唤醒，才会继续执行。

（2）同步阻塞：当执行同步的方法的时候，等待另一线程释放锁的这个过程

（3）sleep，join阻塞：当执行sleep，或者只join方法也会引起Blocked。

通过图片先来看看线程正常运行时候的图：

然后我们在看看完成的图：

我不知道大家有没有我当初的烦恼，我为了理解Blocked想了很久，到底什么是阻塞？后面我觉得有了一点明悟，

比如你正在玩的一个游戏的时候，突然你妈妈叫你去吃饭，所以你只能停下来，吃完饭后再继续回来玩。有或者说停电啊等各种原因。

好了，说完上面线程的状态，我们继续谈论一下下面的问题：

1.在上篇博文介绍的时候，为了保证在多线程同时操作一个对象变量得到我们期望的结果时候，我们使用了volatile关键字，增强了可见性（后面会专门介绍一下，什么是可见性，还有happens-before原则）在线程中我们是怎么保证在多个线程访问变量的时候，得到我们想要的结果呢？

2.首先我们先想想在多线程中i++，i--这种操作是不是安全的呢？到底我们常说的线程安全是什么呢？

（1）在多线程中i++，i--操作不一定是安全的

（2）线程安全的定义有很多，但是我觉得核心的就是：

一个实例变量，或者是实例对象，在多个线程同时访问同一个对象，变量的时候（并发），程序运行的结果跟我们期待的一样，这就是线程安全的。

3.如果还有疑问的话，我觉得实例是最好的说明：（i++，i--操作的小例子）：

首先定义一个方法：

package com.zqu.yqy.scdn.test.test003;

public class MyMethod {
	public void testMethodA(){
		for(int i=1;i<100;i++){
			System.out.println(i);
		}
	}
	public void testMethodB(){
		for(int i=100;i>0;i--)
		{
			System.out.println(i);
		}
	}

}

然后定义两个线程：

package com.zqu.yqy.scdn.test.test003;

public class newThread extends Thread{
	private MyMethod myMethod;

	public newThread(MyMethod myMethod) {
		this.myMethod = myMethod;
	}

	public void run() {
		myMethod.testMethodA();
		try {
			Thread.sleep(2000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		myMethod.testMethodB();
	}
}

package com.zqu.yqy.scdn.test.test003;

public class newThread01 extends Thread{
	private MyMethod myMethod;

	public newThread01(MyMethod myMethod) {
		this.myMethod = myMethod;
	}
	public void run() {
		myMethod.testMethodA();
		try {
			Thread.sleep(2000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		myMethod.testMethodB();
	}
}

最后是运行测试：

package com.zqu.yqy.scdn.test.test003;

public class run {
	public static void main(String[] args) {
		MyMethod my = new MyMethod();
		newThread t1 = new newThread(my);
		newThread01  t2 = new newThread01(my);
		t1.start();
		t2.start();
	}

}

在放出结果以前，我想问的是，我们期待的结果是什么？应该是打印1到100，还有就是从100到一把？但是结果真的是我们所期待的吗？

当然不是，我看看截图就知道了：

为什么会出现这种情况呢？我们可以使用什么方法可以避免呢？

答案好很多，我想说的就是同步synchronized方法，还有J.U.C包下的Lock里面的ReentrantLock锁机制，后面会一一介绍。

好了，今天就到这里，有什么不对的或者疑问都可以提出来，谢谢啦！