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

向右看齐 2022-09-26 08:40 205阅读 0赞

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

没看过的话可以看看（[点击打开链接][Link 1]），里面也有一些需要注意的地方，比如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。

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

![Center][]

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

![Center 1][]

我不知道大家有没有我当初的烦恼，我为了理解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到一把？但是结果真的是我们所期待的吗？

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

![Center 2][]![Center 3][]  
为什么会出现这种情况呢？我们可以使用什么方法可以避免呢？

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

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

[Link 1]: http://blog.csdn.net/yqynsmile/article/details/52352268
[Center]: /images/20220717/d4b638139f9e472f85217cb3fe69d152.png
[Center 1]: /images/20220717/9035d800f2e84178b11569f7a6942fac.png
[Center 2]: https://img-blog.csdn.net/20160921145114334?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center
[Center 3]: /images/20220717/8736249e534d4bea8353d7c65915f14a.png