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

----------------------------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

 

sleep(time)throws InterruptedException: 要运行的代码都是后期定义的。

 

所以创建线程的第一种方式是：继承Thread类。

 

原因：要覆盖run方法，定义线程要运行的代码。

 

步骤：

 

1，继承Thread类。

 

2，覆盖run方法。将线程要运行的代码定义其中。

 

3，创建Thread类的子类对象，其实就是在创建线程，调用start方法。 如果自定义的类中有多线程要运行的代码。

 

但是该类有自己的父类。 那么就不可以在继承Thread。怎么办呢？ Java给我们提供了一个规则。Runnable接口。 如果

 

自定义类不继承Thread，

 

 

也可以实现Runnable接口。并将多线程要运行的代码存放在Runnable的run方法中。 这样多线程也可

 

以帮助该类运行。

 

这样的操作有一个好处：避免了单继承的局限性。

 

创建线程的第二种方式：

 

实现Runnable接口。

 

步骤：

 

1，定义了实现Runnable接口。

 

2，覆盖接口的run方法。将多线程要运行的代码存入其中。

 

3，创建Thread类的对象(创建线程),并将Runnable接口的子类对象作为参数传递给Thread的构造函

 

数。 为什么要传递？因为线程要运行的代码都在Runnable子类的run方法中存储。所以要将该

 

run方法所属的对象 传递给Thread。让Thread线程去使用该对象调用其run方法。

 

4，调用Thread对象的start方法。开启线程。 动手写代码。 两种方式的特点： 实现方式，因为避免了

 

单继承的局限性，所以创建线程建议使用第二种方式。

 

第一重点：创建线程的两种方式

 

 

作为了解： 线程的状态。

 

1，被创建。

 

2，运行。

 

3，冻结。

 

4，消亡。

 

其实还有一种特殊的状态：临时状态。

 

 该临时状态的特点： 具备了执行资格，但不具备执行权。 冻结状态的

 

特点： 放弃了执行资格。 多线程具备随机性。因为是由cpu不断的快速切换造成的。 就有可能会产生多线程的安全问题。

 

问题的产生的原因： 几个关键点：

 

1，多线程代码中有操作共享数据。

 

2，多条语句操作该共享数据。

 

当具备两个关键点时， 有一个线程对多条操作共享数据的代码执行的一部分。还没有执行完，另一个线程开始

 

参与执行。 就会发生数据错误。

 

解决方法： 当一个线程在执行多条操作共享数据代码时，其他线程即使获取了执行权，也不可以参与操作。

 

Java就对这种解决方式提供了专业的代码。 同步 同步的原理：就是将部分操作功能数据的代码进行加锁。 示例：火车上

 

的卫生间。 同步的表现形式：

 

1，同步代码块。

 

2，同步函数。

 

 

两者有什么不同： 同步代码块使用的锁是任意对象。 同步函数使用的锁是this。 注意：对于static的同步函数，使

 

用的锁不是this。是 类名.class 是该类的字节码文件对象。

 

涉及到了单例设计模式的懒汉式。

 

同步的好处：解决了线程的安全问题。 

 

弊端： 较为消耗资源。

 

同步嵌套后，容易死锁。

 

要记住：同步使用的前提：

 

1，必须是两个或者两个以上的线程。

 

2，必须是多个线程使用同一个锁。这是才可以称为这些线程被同步了。 死锁代码一定会写。但开发时一定注

 

意避免。

 

 

 

 

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