黑马程序员-多线程（下）

最新推荐文章于 2025-03-18 00:28:03 发布

原创最新推荐文章于 2025-03-18 00:28:03 发布 · 836 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java

java 专栏收录该内容

34 篇文章

订阅专栏

-----------android培训、java培训、java学习型技术博客、期待与您交流！ ------------

一、多线程安全问题：

1、原因：

当程序的多条语句在操作线程共享数据时(如买票例子中的票就是共享资源)，由于线程的随机性，导致一个线程对多条语句只执行了一部分，其余的还没执行完，这时另一个线程抢夺到cpu执行权参与进来执行，此时就导致共享数据发生错误。比如买票例子中打印重票和错票的情况。

2、解决方法：

对多条操作共享数据的语句进行同步，只能让一个线程都执行完。在一个线程执行过程中，其他线程不可以参与执行。

二、共享资源

1、定义

共享资源一般是以对象形式存在的内存片段，但也可以是文件、输入输出端口，或者是打印机。也称为临界资源。每次仅允许一个进程访问临界资源。

2、控制

要控制对共享资源的访问，得先把它包装进一个对象。将类中的数据成员都声明为private的，这样只能通过成员方法来访问这些数据，所以可以把所有要访问这个资源的方法标记为synchronized。这样当某个任务处于一个标记为synchronized方法的调用中，那么在这个线程从这个方法返回之前，其他所有要调用类中任何标记为synchronized方法的线程都会被阻塞。

3、注意：

在使用并发时，将域设置为private是非常重要的，否则，synchronized关键字就不能防止其他任务直接访问域，这样就会产生冲突。

三、什么是锁?锁的作用是什么?

1、所有对象都自动含有单一的锁（监视器）。

2、锁的作用：

是保证线程同步，解决线程安全问题。

3、原理：

该对象在建立的时候有一个标志位，该位为1就是“锁开”状态；为0就是“锁闭”。当任务在对象上调用其任意synchronized方法时，将标志位置为0，此对象被加锁，这时该对象上的其他synchronized方法只有等到前一个方法调用完毕，并将标志位重新置为1，释放了锁之后才能被调用。
持有锁的线程可以在同步中执行，没有锁的线程即使获得cpu执行权，也进不去。

4、代码示例：

synchronized void f() { /* ... */ }
synchronized void g() { /* ... */ }

如果某个任务对对象调用了f()，对于同一个对象而言，就只能等到f()调用结束并释放了锁之后，其他任务才能调用f()和g()。所以，对于某个特定对象来说，其所有synchronized方法共享同一个锁，这可以被用来防止多个任务同时访问对象内存。

5、经典例子——火车上的卫生间。

四、什么时候使用同步

如果你正在写一个变量，他可能接下来将被另一个线程读取；或者你正在读取一个上一次已经被另一个线程写过的变量，那么你必须使用同步。并且，读写线程都必须用相同的监视器锁同步。

五、同步的使用规则：

如果在你的类中有超过一个方法在处理关键共享资源，那么你必须同步所有访问关键共享资源的方法，否则未同步的相关方法将会随意地忽略这个对象锁，可以被随意调用，它们就不会正确地工作。

六、同步的好处和弊端

好处：同步解决了多线程的安全问题
弊端：多线程都需要判断锁，比较消耗资源

七、同步的前提：

(1)必须保证有两个或两个以上线程
(2)必须是多个线程使用同一个锁，即多条语句在操作线程共享数据
(3)必须保证同步中只有一个线程在运行

八、（重点）同步的使用范围

1、为什么要限定同步的范围？

run()方法中的代码如果全放在synchronize中，就变成了单线程，同步就失去了意义。哪部分才有必要放进synchronize中呢？那就是所有线程的共享数据。
而各线程自己独立拥有的、各线程可以同时处理而不会互相影响的数据不必放进去。

2、分辨哪些代码该同步，哪些代码不该同步的方法：

(1)明确哪些代码是多线程运行代码；
(2)明确各线程的共享数据；
(3)明确多线程运行代码中哪些语句是操作共享数据的。
(4)把共享数据设置为private；
(5)把操作共享数据的代码用synchronize围起来
小诀窍：一般while或for语句中的局部变量都不是共享数据，每个线程都有自己的局部变量，所以不要放到同步中

九、同步的两种表现形式：

1、同步函数

（1）定义

在方法上使用synchronized关键字。

（2）锁的选取

1）非静态同步函数

使用被调用的函数所在的当前对象this。

原因：函数需要被对象调用。函数都有一个所属对象引用，就是this。所以同步函数使用的锁是this。

2）如果同步函数被静态修饰后，使用的锁是什么呢？

通过验证，发现不再是this。因为静态方法中也不可以定义this。
静态进内存时，内存中并没有本类对象，但是一定有该类所对应的字节码文件对象，该对象的类型是Class，名称是：类名.class。这个字节码对象在内存中是唯一的，因为字节码文件只在内存中加载一次。
结论：静态同步函数使用的的锁是该方法所在的类的字节码文件对象，即类名.class文件

代码示例：

class Ticket implements Runnable {
	private static int tick = 100;
	// Object obj = new Object();
	boolean flag = true;

	public void run() {
		if (flag) {
			while (true) {
				synchronized (Ticket.class)// 静态用的是class锁，如果在同步函数中去掉静态就用this。
				{
					if (tick > 0) {
						try {
							Thread.sleep(10);
						} catch (Exception e) {
						}
						System.out.println(Thread.currentThread().getName()
								+ "....code : " + tick--);
					}
				}
			}
		} else
			while (true)
				show();
	}

	public static synchronized void show() {
		if (tick > 0) {
			try {
				Thread.sleep(10);
			} catch (Exception e) {
			}
			System.out.println(Thread.currentThread().getName()
					+ "....show.... : " + tick--);
		}
	}
}

class StaticMethodDemo {
	public static void main(String[] args) {

		Ticket t = new Ticket();

		Thread t1 = new Thread(t);
		Thread t2 = new Thread(t);
		t1.start();
		try {
			Thread.sleep(10);
		} catch (Exception e) {
		}
		t.flag = false;
		t2.start();
	}
}

/*output:
Thread-0....code : 100
Thread-0....code : 99
Thread-0....code : 98
Thread-0....code : 97
Thread-0....code : 96
Thread-0....code : 95
Thread-1....show.... : 94
Thread-1....show.... : 93
Thread-1....show.... : 92
Thread-1....show.... : 91
*/

（3）格式：

修饰词 synchronized 返回值类型函数名(参数列表)
{

需同步的代码;
}

在jdk1.5后，用lock锁取代了synchronized，个人理解也就是对同步代码块做了修改，并没有提供对同步方法的修改，主要还是效率问题吧。

（4）代码示例：

/*
需求：
银行有一个金库。
有两个储户分别存300员，每次存100，存3次。

目的：该程序是否有安全问题，如果有，如何解决？


如何找问题：
1，明确哪些代码是多线程运行代码。
2，明确共享数据。
3，明确多线程运行代码中哪些语句是操作共享数据的。
 */
class Bank// 银行金库
{
	private int sum;

	public synchronized void add(int n)// 定义同步函数防止安全问题
	{
		sum = sum + n;
		try {
			Thread.sleep(10);
		} catch (Exception e) {
		}// 判断下是否有安全问题
		System.out.println("sum=" + sum);
	}
}

class Cus implements Runnable// 存户用多线程存钱
{
	private Bank b = new Bank();

	public void run() {
		for (int x = 0; x < 3; x++) {
			b.add(100);
		}
	}
}

class BankDemo {
	public static void main(String[] args) {
		Cus c = new Cus();
		Thread t1 = new Thread(c);
		Thread t2 = new Thread(c);
		t1.start();
		t2.start();
	}
}

/*output:
sum=100
sum=200
sum=300
sum=400
sum=500
sum=600
*/

2、同步代码块：

（1）定义

希望同步方法内部的部分代码而不是同步整个方法，这样分离出来的代码段称为同步代码块，也叫临界区。

（2）锁的选取

理论上：可以指定需要获取哪个对象的同步锁，使用synchronized的代码块同样需要锁，但他的锁可以是任意对象。

最合理的选取方式：使用其方法正在被调用的当前对象：synchronized(this)。

原因：如果在this上同步（即使用this对象的锁），那么该对象其他的同步函数和同步代码块（临界区）就不能被其他任务调用了，这样就将该类的临界区都限制在了同步的范围内，相对来说效率较高。

在不同锁上同步示例：

// Synchronizing on another object.
import static net.mindview.util.Print.*;

class DualSynch {
	private Object syncObject = new Object();

	public synchronized void f() {
		for (int i = 0; i < 5; i++) {
			print("f()");
			Thread.yield();
		}
	}

	public void g() {
		synchronized (syncObject) {
			for (int i = 0; i < 5; i++) {
				print("g()");
				Thread.yield();
			}
		}
	}
}

public class SyncObject {
	public static void main(String[] args) {
		final DualSynch ds = new DualSynch();
		new Thread() {
			public void run() {
				ds.f();
			}
		}.start();
		ds.g();
	}
} /*
 * Output: (Sample) g() f() g() f() g() f() g() f() g() f()
 */// :~

解释：DualSync.f( )在this上同步（通过整个同步方法），而g( )有一个在syncObject上同步的synchronized块。因此，这两个同是时互相独立的。其中main( )线程用来调用g( )；Thread线程用来调用f( )。所以两个任务可以同时进人同一个对象，只要这个对象上的方法是在不同锁上同步的即可。

（3）注意：

1)虽然同步代码快的锁可以使任何对象，但是在进行多线程通信使用同步代码快时，必须保证同步代码块的锁的对象相同，否则会报错。
2)同步函数的锁是this，也要保证同步函数的锁的对象和调用wait、notify和notifyAll的对象是同一个对象，也就是都是this锁代表的对象。

（4）格式：

synchronized(对象)
{
需同步的代码;
}

（5）代码示例：

class Ticket implements Runnable {
	private int tick = 1000;
	Object obj = new Object();

	public void run() {
		while (true) {
			synchronized (obj)// 定义同步锁
			{
				if (tick > 0) {
					// try{Thread.sleep(10);}catch(Exception e){}
					System.out.println(Thread.currentThread().getName()
							+ "....sale : " + tick--);
				}
			}
		}
	}
}

class TicketDemo2 {
	public static void main(String[] args) {

		Ticket t = new Ticket();
		Thread t1 = new Thread(t);
		Thread t2 = new Thread(t);
		Thread t3 = new Thread(t);
		Thread t4 = new Thread(t);
		t1.start();
		t2.start();
		t3.start();
		t4.start();
	}
}

/*output(example)
Thread-3....sale : 1000
Thread-3....sale : 999
Thread-3....sale : 998
Thread-3....sale : 997
Thread-3....sale : 996
Thread-3....sale : 995
...
*/

十、同步函数和同步代码块的区别：

1、锁

（1）同步函数使用的锁是固定对象；

（2） this同步代码块使用的锁可以是任意对象。

2、效率

（1）同步函数是对整个方法进行控制；

（2）同步代码块是对方法内部的部分代码进行控制；

结论：同步代码块可以使多个任务访问对象的时间性能得到显著提高。因此一般定义同步时，建议使用同步代码块。

十一、(重点)多线程的单例设计模式：

1、饿汉式：

class Single
{
	private Single(){} //私有化构造函数，不让别的类建立该类对象。
	private static Single s = new Single(); //创建私有并静态的本类对象。
	public static Single getInstance()//定义公有并静态的方法，返回该对象。
	{ 
		return s;
	}
}

2、懒汉式：

class Single
{
	private Single(){} 
	private static Single s;
	public static Single getInstance()
	{
		if(s==null)
			s=new Single();
		return s;
	}
}

十二、(重点)饿汉式和懒汉式的区别：

1、对象的创建

(1)饿汉式是类一加载进内存就创建好了对象；
(2)懒汉式则是类加载进内存的时候，对象还没有存在，只有调用了getInstance()方法时，对象才开始创建。

2、线程安全

懒汉式是实例（对象）的延迟加载，如果多个线程同时操作懒汉式时就有可能出现线程安全问题，解决线程安全问题可以加同步来解决。但是加了同步之后，每一次都要比较锁，效率就变慢了，所以可以加双重判断来提高程序效率。

如将上述懒汉式的Instance函数改成同步：

class Single
{
	private Single(){}

	private static Single s = null;

	public static Single getInstance()
	{
		if(s==null)
		{
			synchronized(Single.class)//注意：加同步时使用的锁是Single.class
			{
				if(s==null)
					s = new Single();
			}
		}
		return s;
	}
}

class SingleDemo
{
	public static void main(String[] args) 
	{
		Single s = Single.getInstance();
	}
}

以上也可称为“延迟加载的单例设计模式示例”。

十三、线程的几种状态：

1、新建：
创建一个线程有两种方式，一是继承Thread类，二是实现Runnable接口。

当一个线程对象被创建，但是没有开启，这个时候，只是为线程对象开辟了内存空间和初始化数据。这个状态很短暂。
注意：Thread类的方法调用了底层程序；因为java自己不会创造线程，只能调用windows创造的线程

2、就绪（可运行）：
新建的对象调用start方法，就开启了线程，线程就到了就绪状态。在这个状态的线程对象，具有执行资格，没有执行权。只要调度器把时间片分配给线程，线程就可以运行。

3、运行：
当线程对象获取到了CPU的时间片。在这个状态的线程对象，既有执行资格，也有执行权。

4、阻塞：
运行过程中的线程由于某些原因(比如wait,sleep)，释放了执行资格和执行权。当然，他们可以回到运行状态。只不过，不是直接回到，而是先回到就绪状态。

5、死亡：
当线程对象调用的run方法结束，就让线程对象死亡，在内存中变成了垃圾。

十四、阻塞状态：

一个任务进入阻塞状态，可能有如下原因：

1、当线程调用了自身的sleep(milliseconds)方法或其他线程的join()方法，就会进入休眠状态（该状态既停止当前线程，但并不释放所占有的资源）。当sleep()结束或join()结束后，该线程进入就绪状态，继续等待OS分配时间片；

2、当线程刚进入就绪状态（注意，还没运行），发现将要调用的资源被synchroniza（同步），获取不到锁标记，将会立即进入锁池状态，等待获取锁标记（这时的锁池里也许已经有了其他线程在等待获取锁标记，这时它们处于队列状态，既先到先得），一旦线程获得锁标记后，就转入就绪状态，等待OS分配CPU时间片；

3、当线程调用wait()方法后会进入等待队列（进入这个状态会释放所占有的所有资源，与阻塞状态不同），进入这个状态后，是不能自动唤醒的，必须依靠其他线程调用notify()或notifyAll()方法才能被唤醒（由于notify()只是唤醒一个线程，但我们由不能确定具体唤醒的是哪一个线程，也许我们需要唤醒的线程不能够被唤醒，因此在实际使用时，一般都用notifyAll()方法，唤醒有所线程），线程被唤醒后会进入锁池，等待获取锁标记。

示意图如下：

十五、wait()、notify()、notifyAll()

1、具体用法

wait()：
使一个线程处于等待状态，并且释放所持有的对象的lock。

notify()：
唤醒一个处于等待状态的线程，注意的是在调用此方法的时候，并不能确切的唤醒某一个等待状态的线程，而是由JVM确定唤醒哪个线程(一般是最先开始等待的线程，即线程池中的第一个线程)，而且不是按优先级。

Allnotity()：
唤醒所有处入等待状态的线程，注意并不是给所有唤醒线程一个对象的锁，而是让它们竞争。

2、为什么这些方法都只存在于同步中？

因为这些方法的作用是对持有监视器（锁）的线程进行操作，而只有同步才具有锁。

3、为什么这些方法必须使用同一把锁？

因为这些方法在操作同步中线程时，都必须要标识它们所操作线程持有的锁，只有同一个锁上的被等待线程，可以被同一个锁上notify唤醒，而不可以对不同锁中的线程进行唤醒。
也就是说，等待和唤醒必须是同一个锁。

4、为什么这些用来操作线程的方法定义在Object类中？

因为这些方法的作用是对持有监视器（锁）的线程进行操作，而锁可以是任意对象，所以可以被任意对象调用的方法必须定义在Object类中。

5、wait()、notify()、notifyAll()的定义和使用规则

(1)这些方法只存在于同步中；
(2)使用这些方法时必须要指定所属的锁，即被哪个锁调用这些方法；
(3)而锁可以是任意对象，所以任意对象调用的方法就定义在Object中。

十六、sleep()：

使一个正在运行的线程处于睡眠状态，是一个静态方法，调用此方法要捕捉InterruptedException异常。

sleep()和wait()的区别：
1、这两个方法来自不同的类，sleep()来自Thread类，而wait()来自Object类。
2、sleep是Thread的静态类方法，谁调用的谁去睡觉，即使在a线程里调用了b的sleep方法，实际上还是a去睡觉，要让b线程睡觉要在b的代码中调用sleep。而wait()是Object类的非静态方法。
3、sleep()释放资源不释放锁（它不操作锁），而wait()释放资源释放锁；
4、使用范围：wait,notify和notifyAll只能在同步控制方法或者同步控制块里面使用，因为它们要操作锁；而因为sleep没有对锁的操作，所以sleep可以在任何地方使用。

十七、死锁

两个线程对两个同步对象具有循环依赖时，就会发生死锁。即同步嵌套同步，而锁却不同。

示例代码：

/*
死锁。
同步中嵌套同步。
 */
class Ticket implements Runnable {
	private int tick = 1000;
	Object obj = new Object();
	boolean flag = true;

	public void run() {
		if (flag) {
			while (true) {
				synchronized (obj) {
					show();
				}
			}
		} else
			while (true)
				show();
	}

	public synchronized void show()// this
	{
		synchronized (obj) {
			if (tick > 0) {
				try {
					Thread.sleep(10);
				} catch (Exception e) {
				}
				System.out.println(Thread.currentThread().getName()
						+ "....code : " + tick--);
			}
		}
	}
}

/* 死锁,两个锁互相嵌套 */
class Test implements Runnable {
	private boolean flag;

	Test(boolean flag) {
		this.flag = flag;
	}

	class MyLock {
	}

	MyLock locka = new MyLock();
	MyLock lockb = new MyLock();

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

class DeadLockDemo {
	public static void main(String[] args) // 主函数多线程验证
	{

		Ticket t = new Ticket();

		Thread t1 = new Thread(t);
		Thread t2 = new Thread(t);
		t1.start();
		try {
			Thread.sleep(10);
		} catch (Exception e) {
		}
		t.flag = false;
		t2.start();
	}
}

/*output:
Thread-0....code : 1000
Thread-0....code : 999
Thread-0....code : 998
Thread-0....code : 997
Thread-0....code : 996
Thread-0....code : 995
Thread-0....code : 994
Thread-0....code : 993
Thread-0....code : 992
Thread-0....code : 991
*/

十八、多线程间通讯：

多线程间通讯就是多个线程在操作同一资源,但是操作的动作不同。

1、为什么要通信

多线程并发执行的时候, 如果需要指定线程等待或者唤醒指定线程, 那么就需要通信.比如生产者消费者的问题，生产一个消费一个,生产的时候需要负责消费的进程等待,生产一个后完成后需要唤醒负责消费的线程,同时让自己处于等待，消费的时候负责消费的线程被唤醒，消费完生产的产品后又将等待的生产线程唤醒，然后使自己线程处于等待。这样来回通信，以达到生产一个消费一个的目的。

2、怎么通信

在同步代码块中, 使用锁对象的wait()方法可以让当前线程等待, 直到有其他线程唤醒为止。使用锁对象的notify()方法可以唤醒一个等待的线程，或者notifyAll唤醒所有等待的线程。多线程间通信用sleep很难实现，睡眠时间很难把握。

3、代码示例：

/*
对于多个生产者和消费者。
为什么要定义while判断标记。
原因：让被唤醒的线程再一次判断标记。


为什么定义notifyAll，
因为需要唤醒对方线程。
因为只用notify，容易出现只唤醒本方线程的情况。导致程序中的所有线程都等待。

 */

class Resource {
	private String name;
	private int count = 1;
	private boolean flag = false;

	// t1 t2
	public synchronized void set(String name) {
		while (flag)
			try {
				this.wait();
			} catch (Exception e) {
			}// t1(放弃资格) t2(获取资格)
		this.name = name + "--" + count++;

		System.out.println(Thread.currentThread().getName() + "...生产者.."
				+ this.name);
		flag = true;
		this.notifyAll();
	}

	// t3 t4
	public synchronized void out() {
		while (!flag)
			try {
				wait();
			} catch (Exception e) {
			}// t3(放弃资格) t4(放弃资格)
		System.out.println(Thread.currentThread().getName() + "...消费者........."
				+ this.name);
		flag = false;
		this.notifyAll();
	}
}

class Producer implements Runnable {
	private Resource res;

	Producer(Resource res) {
		this.res = res;
	}

	public void run() {
		while (true) {
			res.set("+商品+");
		}
	}
}

class Consumer implements Runnable {
	private Resource res;

	Consumer(Resource res) {
		this.res = res;
	}

	public void run() {
		while (true) {
			res.out();
		}
	}
}

class ProducerConsumerDemo {
	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();

	}
}

/*output:
Thread-1...生产者..+商品+--775625
Thread-2...消费者.........+商品+--775625
Thread-0...生产者..+商品+--775626
Thread-3...消费者.........+商品+--775626
Thread-0...生产者..+商品+--775627
Thread-2...消费者.........+商品+--775627
Thread-1...生产者..+商品+--775628
Thread-2...消费者.........+商品+--775628
Thread-0...生产者..+商品+--775629
Thread-3...消费者.........+商品+--775629
Thread-0...生产者..+商品+--775630
Thread-2...消费者.........+商品+--775630
Thread-1...生产者..+商品+--775631
Thread-2...消费者.........+商品+--775631
Thread-0...生产者..+商品+--775632
Thread-3...消费者.........+商品+--775632
*/