黑马程序员_基础复习五(线程)

最新推荐文章于 2025-05-11 14:15:46 发布

dupengtao

最新推荐文章于 2025-05-11 14:15:46 发布

阅读量139

点赞数

分类专栏：黑马程序员文章标签： java 设计模式

本文链接：https://blog.youkuaiyun.com/dupengtao/article/details/84360644

版权

黑马程序员专栏收录该内容

12 篇文章

订阅专栏

----------------------------android培训、java培训、期待与您交流！----------------------------------

感想：

总结：

获取线程名称：

.getName();

返回现在所调用的线程对象

Thread.currentThread;

懒汉式和饿汗式的区别：

1.懒汗式的特点是延时加载。

懒汉的延时加载有没有什么问题？

答：在多线程访问时可能出现安全问题，可以通过加同步来解决，可以同同步代码块或者同步函数来解

决，但是效率低，可以用双从判断来提高些效率，用的锁是该类的字节码对象，类名.class.

class Single
{
	private static Single s = null;
	private Single(){}


	public static  Single getInstance()
	{
		if(s==null)
		{
			synchronized(Single.class)
			{
				if(s==null)
					//--->A;
					s = new Single();
			}
		}
		return s;
	}
}

死锁程序：

class Test implements Runnable
{
	private boolean flag;
	Test(boolean flag)
	{
		this.flag = flag;
	}

	public void run()
	{
		if(flag)
		{
			while(true)
			{
				synchronized(MyLock.locka)
				{
					System.out.println("if locka ");
					synchronized(MyLock.lockb)
					{
						System.out.println("if lockb");					
					}
				}
			}
		}
		else
		{
			while(true)
			{
				synchronized(MyLock.lockb)
				{
					System.out.println("else lockb");
					synchronized(MyLock.locka)
					{
						System.out.println("else locka");
					}
				}
			}
		}
	}
}

class MyLock
{
	static Object locka = new Object();
	static Object lockb = new Object();
}

class  DeadLockTest
{
	public static void main(String[] args) 
	{
		Thread t1 = new Thread(new Test(true));
		Thread t2 = new Thread(new Test(false));
		t1.start();
		t2.start();
	}
}

同步的前提：

1.必须要有两个或者两个以上的线程。

2.必须是多个线程使用同一个锁。

wait:notify();notifyAll();

都使用在同步中，因为要对持有监视器(锁)的线程操作。所以要使用在同步中，因为只有同步才具有锁。

为什么这些操作线程的方法要定义Object类中呢？

因为这些方法在操作同步中线程时，都必须要标识它们所操作线程只有的锁，只有同一个锁上的被等待线程，

可以被同一个锁上notify唤醒。不可以对不同锁中的线程进行唤醒。也就是说，等待和唤醒必须是同一个锁。而锁可以是任

意对象，所以可以被任意对象调用的方法定义Object类中。

JDK1.5 中提供了多线程升级解决方案。将同步Synchronized替换成现实Lock操作。将Object中的wait，notify

notifyAll，替换了Condition对象。该对象可以Lock锁进行获取。该示例中，实现了本方只唤醒对方操作。 Lock:替代

了Synchronized lock unlock newCondition() Condition：替代了Object wait notify notifyAll await();

signal(); signalAll();

import java.util.concurrent.locks.*;

class ProducerConsumerDemo2 
{
	public static void main(String[] args) 
	{
		Resource r = new Resource();

		Producer pro = new Producer(r);
		Consumer con = new Consumer(r);

		Thread t1 = new Thread(pro);
		Thread t2 = new Thread(pro);
		Thread t3 = new Thread(con);
		Thread t4 = new Thread(con);

		t1.start();
		t2.start();
		t3.start();
		t4.start();

	}
}

class Resource
{
	private String name;
	private int count = 1;
	private boolean flag = false;
			//  t1    t2
	private Lock lock = new ReentrantLock();

	private Condition condition_pro = lock.newCondition();
	private Condition condition_con = lock.newCondition();



	public  void set(String name)throws InterruptedException
	{
		lock.lock();
		try
		{
			while(flag)
				condition_pro.await();//t1,t2
			this.name = name+"--"+count++;

			System.out.println(Thread.currentThread().getName()+"...生产者.."+this.name);
			flag = true;
			condition_con.signal();
		}
		finally
		{
			lock.unlock();//释放锁的动作一定要执行。
		}
	}


	//  t3   t4  
	public  void out()throws InterruptedException
	{
		lock.lock();
		try
		{
			while(!flag)
				condition_con.await();
			System.out.println(Thread.currentThread().getName()+"...消费者........."+this.name);
			flag = false;
			condition_pro.signal();
		}
		finally
		{
			lock.unlock();
		}
		
	}
}

class Producer implements Runnable
{
	private Resource res;

	Producer(Resource res)
	{
		this.res = res;
	}
	public void run()
	{
		while(true)
		{
			try
			{
				res.set("+商品+");
			}
			catch (InterruptedException e)
			{
			}
			
		}
	}
}

class Consumer implements Runnable
{
	private Resource res;

	Consumer(Resource res)
	{
		this.res = res;
	}
	public void run()
	{
		while(true)
		{
			try
			{
				res.out();
			}
			catch (InterruptedException e)
			{
			}
		}
	}
}

stop方法已经过时。如何停止线程？

只有一种，run方法结束。开启多线程运行，运行代码通常是循环结构。只要控制住循环，就可以让run方法结束，

也就是线程结束。特殊情况：当线程处于了冻结状态。就不会读取到标记。那么线程就不会结束。当没有指定的方式让

冻结的线程恢复到运行状态是，这时需要对冻结进行清除。强制让线程恢复到运行状态中来。这样就可以操作标记让线程

结束。 Thread类提供该方法 interrupt();

进程：正在执行的程序。

线程：是进程中用于控制程序执行的控制单元(执行路径，执行情景) 进程中至少有一个线程。

对于JVM，启动时，只好有两个线程：jvm的主线程。jvm的垃圾回收线程。

如何在程序中自定义线程呢？

Java给我们提供了对象线程这类事物的描述。该类是Thread 该类中定义了，创建线程对象的方法(构造函数). 提供

了要被线程执行的代码存储的位置（run()）还定义了开启线程运行的方法(start()).

同时还有一些其他的方法用于操作线程： static Thread currentThead(): String getName(): static void