线程的一些知识_try thread.sleep-优快云博客

本文链接：https://blog.youkuaiyun.com/warmcurrent/article/details/17503425

本文通过两个示例探讨了Java中线程同步机制的具体应用。第一个示例展示了notify()方法仅能唤醒因调用wait()而等待的线程，而不会影响由sleep()暂停的线程。第二个示例则讨论了在使用synchronized关键字时，同步对象锁的粒度问题，即整体同步与单元同步之间的区别及它们是否会产生冲突。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1.notify()只响应wait()的情况，不响应sleep()的情况。

package com.test;

import java.util.ArrayList;
import java.util.HashMap;

public class Test3
{
	public static void main(String[] args)
	{
		Test3 t = new Test3();
		t.run();
	}
	public void initT()
	{
	}
	public void run()
	{
		initT();
		RunTest rt1 = new RunTest(0);
		rt1.start();
		try
		{
			Thread.sleep(1000);
		}
		catch (InterruptedException e)
		{
			e.printStackTrace();
		}
		synchronized (rt1)
		{
			//if (rt1.getState().equals(Thread.State.WAITING))
			{
				rt1.notify();
			}			
		}
	}
}
class RunTest extends Thread
{
	private Integer _i = null;
	public RunTest(int i)
	{
		_i = i;
	}
	@Override
	public void run()
	{
		System.out.println("sleep");
		synchronized (this)
		{
			try
			{
				Thread.sleep(5000);
			}
			catch (InterruptedException e)
			{
				// TODO Auto-generated catch block
				e.printStackTrace();
			}			
		}
		System.out.println("睡眠结束");
	}
}

2.syn块响应数组和响应数组中的元素冲突吗？

package com.wy.thread.test2;

import java.util.ArrayList;
import java.util.HashMap;

public class Test2
{
	public static void main(String[] args)
	{
		Test2 t = new Test2();
		t.run();
	}
	public void initT()
	{
	}
	public void run()
	{
		initT();
		RunTest rt1 = new RunTest(0);
		rt1.start();
		RunTest rt2 = new RunTest(1);
		rt2.start();
		RunThrowTest rt3 = new RunThrowTest(2);
		rt3.start();
	}
}
class RunThrowTest extends Thread
{
	private Integer _i = null;
	public RunThrowTest(int i)
	{
		_i = i;
	}
	@Override
	public void run()
	{
		Resource.visitRAll(_i);
	}
}
class RunTest extends Thread
{
	private Integer _i = null;
	public RunTest(int i)
	{
		_i = i;
	}
	@Override
	public void run()
	{
		Resource.visitR(_i);
	}
}

final class Resource 
{
	private static HashMap<Integer, ArrayList<String>> _hm = null;
	public Resource()	{}
	static
	{
		_hm = new HashMap<Integer, ArrayList<String>>();
		_hm.put(0, new ArrayList<String>());
		_hm.put(1, new ArrayList<String>());
		_hm.put(2, new ArrayList<String>());
		for(int i=0;i<3;i++)
		{
			for(int j=0;j<10;j++)
			{
				_hm.get(i).add(j+"");
			}
		}
	}
	public static void visitR(Integer i)
	{
		//本例就是来检测这个的，看hashmap中的同步是整体的还是独立的
		//答案是独立的
		synchronized (_hm.get(i))
		{
			for(int j=0;j<_hm.get(i).size();j++)
			{
				try
				{
					//if(i==2)	Thread.sleep(100);
					Thread.sleep(100);
				}
				catch (Exception e)
				{
				}
				System.out.println(_hm.get(i).get(j));
			}
		}
	}
	public static void visitRAll(Integer i)
	{
		//观察独立同步和整体同步相互干扰吗？
		//答案是不相互干扰
		synchronized (_hm)
		{
			for(int j=0;j<_hm.get(i).size();j++)
			{
				try
				{
					Thread.sleep(100);
				}
				catch (Exception e)
				{
				}
				System.out.println(_hm.get(i).get(j));
			}
		}
	}
}

这就导致一个很严重的问题，就是整体同步性和单元同步性相互会干扰。