7:多线程

基本概念

进程:正在进行中的程序(直译).

线程:就是进程中一个负责程序执行的控制单元(执行路径) 

一个进程中可以多执行路径,称之为多线程,一个进程中至少要有一个线程。 

开启多个线程是为了同时运行多部分代码。 

每一个线程都有自己运行的内容。这个内容可以称为线程要执行的任务。 

多线程好处:解决了多部分同时运行的问题。

多线程的弊端:线程太多回到效率的降低。 

其实应用程序的执行都是cpu在做着快速的切换完成的。这个切换是随机的。 

JVM启动时就启动了多个线程,至少有两个线程可以分析的出来。

1,执行main函数的线程, 

  该线程的任务代码都定义在main函数中。

2,负责垃圾回收的线程。

线程创建方法

创建线程方式一:继承Thread类。

步骤: 

1,定义一个类继承Thread类。

2,覆盖Thread类中的run方法。

3,直接创建Thread的子类对象创建线程。

4,调用start方法开启线程并调用线程的任务run方法执行。

可以通过Thread的getName获取线程的名称 Thread-编号(从0开始) 

主线程的名字就是main。

其中Thread.currentThrrad().getName,是获取当前对象的名字

创建线程的第二种方式:实现Runnable接口。

步骤:

1,定义类实现Runnable接口。

2,覆盖接口中的run方法,将线程的任务代码封装到run方法中。

3,通过Thread类创建线程对象,并将Runnable接口的子类对象作为Thread类的构造函数的参数进行传递。

   为什么?因为线程的任务都封装在Runnable接口子类对象的run方法中。

   所以要在线程对象创建时就必须明确要运行的任务。

4,调用线程对象的start方法开启线程。 

实现Runnable接口的好处:

1,将线程的任务从线程的子类中分离出来,进行了单独的封装。

 按照面向对象的思想将任务的封装成对象。

2,避免了java单继承的局限性。

所以,创建线程的第二种方式较为常用。

class Demo implements Runnable// extends Fu //准备扩展Demo类的功能,让其中的内容可以作为线程的任务执行{	public void run() {		show();	}	public void show() {		for (int x = 0; x < 20; x++) {			System.out.println(Thread.currentThread().getName() + "....." + x);		}	}}class ThreadDemo {	public static void main(String[] args) {		Demo d = new Demo();		Thread t1 = new Thread(d);		Thread t2 = new Thread(d);		t1.start();		t2.start();	}}

线程的生命周期

  • 指线程从创建到启动,直至运行结束
  • 可以通过调用Thread类的相关方法影响线程的运行状态

线程安全

线程安全问题产生的原因:

1,多个线程在操作共享的数据。 

2,操作共享数据的线程代码有多条。

当一个线程在执行操作共享数据的多条代码过程中,其他线程参与了运算。 

就会导致线程安全问题的产生。

解决思路;

就是将多条操作共享数据的线程代码封装起来,当有线程在执行这些代码的时候,

其他线程时不可以参与运算的。

必须要当前线程把这些代码都执行完毕后,其他线程才可以参与运算。

在java中,用同步代码块就可以解决这个问题。

同步代码块的格式: 

synchronized(对象)

{

 需要被同步的代码 ;

}

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

同步的弊端:相对降低了效率,因为同步外的线程的都会判断同步锁。 

同步的前提:同步中必须有多个线程并使用同一个锁。

同步函数的使用的锁是this;

同步函数和同步代码块的区别:

同步函数的锁是固定的this。

同步代码块的锁是任意的对象。

建议使用同步代码块。

eg:验证同步函数的锁

class Ticket implements Runnable {	private int num = 100;	// Object obj = new Object();	boolean flag = true;	// 如果是真运行同步代码块,如果假运行同步函数?	public void run() {		// System.out.println("this:"+this);		if (flag)			while (true) {				synchronized (this) {					if (num > 0) {						try {							Thread.sleep(10);						} catch (InterruptedException e) {						}						System.out.println(Thread.currentThread().getName()								+ ".....obj...." + num--);					}				}			}		else			while (true)				this.show();// 调用show方法	}	public synchronized void show() {// 将需要的放进来		if (num > 0) {			try {				Thread.sleep(10);			} catch (InterruptedException e) {			}			System.out.println(Thread.currentThread().getName()					+ ".....function...." + num--);		}	}}class SynFunctionLockDemo {	public static void main(String[] args) {		Ticket t = new Ticket();		// System.out.println("t:"+t);		Thread t1 = new Thread(t);		Thread t2 = new Thread(t);		t1.start();		try {			Thread.sleep(10);		} catch (InterruptedException e) {		}		t.flag = false;// 标记下		t2.start();	}}

需求:储户,两个,每个都到银行存钱每次存100,,共存三次。

class Bank {	private int sum;	// private Object obj = new Object();	public synchronized void add(int num)// 同步函数	{		// synchronized(obj)		// {		sum = sum + num;		// -->		try {			Thread.sleep(10);		} catch (InterruptedException 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();	}}

静态的同步函数使用的锁是:该函数所属字节码文件对象,它不能用this,静态方法中不能有this

可以用 getClass方法获取,也可以用当前  类名.class 表示。class文件只有一份

class Ticket implements Runnable {	private static int num = 100;	// Object obj = new Object();	boolean flag = true;	public void run() {		// System.out.println("this:"+this.getClass());		if (flag)			while (true) {				synchronized (Ticket.class)// (this.getClass())都行				{					if (num > 0) {						try {							Thread.sleep(10);						} catch (InterruptedException e) {						}						System.out.println(Thread.currentThread().getName()								+ ".....obj...." + num--);					}				}			}		else			while (true)				this.show();	}	public static synchronized void show() {		if (num > 0) {			try {				Thread.sleep(10);			} catch (InterruptedException e) {			}			System.out.println(Thread.currentThread().getName()					+ ".....function...." + num--);		}	}}class StaticSynFunctionLockDemo {	public static void main(String[] args) {		Ticket t = new Ticket();		// Class clazz = t.getClass();		// Class clazz = Ticket.class;		// System.out.println("t:"+t.getClass());		Thread t1 = new Thread(t);		Thread t2 = new Thread(t);		t1.start();		try {			Thread.sleep(10);		} catch (InterruptedException e) {		}		t.flag = false;		t2.start();	}}

多线程下的单例

饿汉式(和一起一样)

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

懒汉式 

加入同步为了解决多线程安全问题。

加入双重判断是为了解决效率问题。 

class Single {	private static Single s = null;	private Single() {	}	public static Single getInstance() {		if (s == null)// 多加一步,0进来以后创建完对象。多加一次判断1进来就不是空了就不判断了		{			synchronized (Single.class) {				if (s == null)					// -->0 -->1,0判断完空,创建对象,1进来就来不判断了,直接创建新对象,所以加同步					// 这里用同步函数不好,用代码块好,提高效率					s = new Single();			}		}		return s;	}}

死锁:

情景一:同步的嵌套。

你不给我,我不给你筷子,你的同步有我的同步,我的同步有你同步,

情景二:全部等待

例一:

class Ticket implements Runnable { // 这里有俩把锁this和obj	private int num = 100;	Object obj = new Object();	boolean flag = true;	public void run() {		if (flag)			while (true) {				synchronized (obj) {					show();// 拿着obj想进this				}			}		else			while (true)				this.show();	}	public synchronized void show() {// 拿着this想进obj,互相拿着锁不放。和谐的时候是你进来我出去了		synchronized (obj) // 同步函数加入同步代码块		{			if (num > 0) {				try {					Thread.sleep(10);				} catch (InterruptedException e) {				}				System.out.println(Thread.currentThread().getName()						+ ".....sale...." + num--);			}		}	}}class DeadLockDemo {	public static void main(String[] args) {		Ticket t = new Ticket();		// System.out.println("t:"+t);		Thread t1 = new Thread(t);		Thread t2 = new Thread(t);		t1.start();		try {			Thread.sleep(10);		} catch (InterruptedException e) {		}		t.flag = false; // 切换		t2.start();	}}

例二:

class Test implements Runnable {	private boolean flag;	Test(boolean flag) // 构造函数里赋值	{		this.flag = flag;	}	public void run() {		if (flag) {			while (true)				synchronized (MyLock.locka) // a里有b				{					System.out.println(Thread.currentThread().getName()							+ "..if   locka....");					synchronized (MyLock.lockb) {						System.out.println(Thread.currentThread().getName()								+ "..if   lockb....");					}				}		} else {			while (true)				synchronized (MyLock.lockb) { // b里有a					{						System.out.println(Thread.currentThread().getName()								+ "..else  lockb....");						synchronized (MyLock.locka) {							System.out.println(Thread.currentThread().getName()									+ "..else   locka....");						}					}				}		}	}	class MyLock {		public static final Object locka = new Object();		public static final Object lockb = new Object();	}	class DeadLockTest {		public static void main(String[] args) {			Test a = new Test(true);			Test b = new Test(false);			// 一般线程只有一个对象,因为多线程就是多个线程执行同一个任务,而这里FLAG的值只有俩种情况(真假)			// 也是为了切换			Thread t1 = new Thread(a);			Thread t2 = new Thread(b);			t1.start();			t2.start();		}	}}

new object写在外边,写在里边创建了四个对象,有四把锁,用同步,必须保证多个线程使用同一个锁


线程间通讯

多个线程在处理同一资源,但是任务却不同。

版本1.0

//资源class Resource {	String name;	String sex;}// 输入class Input implements Runnable {	Resource r; // 参数传递	// Object obj = new Object();	Input(Resource r) {		this.r = r;	}	public void run() {		int x = 0;		while (true) {			synchronized (r)			// 不能用this,obj,这里有俩个对象,得保证用一个唯一的对象,用参数的Class文件也可以,但是杀不用炮轰,所以用资源的参数就可以了			{				if (x == 0) {					r.name = "mike";					r.sex = "nan";				} else {					r.name = "丽丽";					r.sex = "女女女女女女";				}			}			x = (x + 1) % 2;		}	}}// 输出class Output implements Runnable {	Resource r;	// Object obj = new Object();	Output(Resource r) {		this.r = r;	}	public void run() {		while (true) {			synchronized (r) {				System.out.println(r.name + "....." + r.sex);			}		}	}}class ResourceDemo {	public static void main(String[] args) {		// 创建资源。		Resource r = new Resource();		// 创建任务。		Input in = new Input(r);		Output out = new Output(r);		// 创建线程,执行路径。		Thread t1 = new Thread(in);		Thread t2 = new Thread(out);		// 开启线程		t1.start();		t2.start();	}}

这个代码会出现一大片,我们希望的是输入一次输出一次,用唤醒等待

等待/唤醒机制。

涉及的方法: 

1,wait(): 让线程处于冻结状态,被wait的线程会被存储到线程池中。 

2,notify():唤醒线程池中一个线程(任意).

3,notifyAll():唤醒线程池中的所有线程。

这些方法都必须定义在同步中。

俩帮小朋友玩游戏,你wait,另一帮玩的不能叫醒你,就像需要同一把锁。

因为这些方法是用于操作线程状态的方法。

必须要明确到底操作的是哪个锁上的线程。

为什么操作线程的方法wait notify notifyAll定义在了Object类中?  

因为这些方法是监视器的方法。监视器其实就是锁。 

锁可以是任意的对象,任意的对象调用的方式一定定义在Object类中。

版本2.0

//资源class Resource {	String name;	String sex;	boolean flag = false;}// 输入class Input implements Runnable {	Resource r;	// Object obj = new Object();	Input(Resource r) {		this.r = r;	}	public void run() {		int x = 0;		while (true) {			synchronized (r) {				if (r.flag)					try {						r.wait();					} catch (InterruptedException e) {					}				// r.wait俩帮小朋友玩游戏,你wait,另一帮不能叫醒你,一把锁				if (x == 0) {					r.name = "mike";					r.sex = "nan";				} else {					r.name = "丽丽";					r.sex = "女女女女女女";				}				r.flag = true;				r.notify();			}			x = (x + 1) % 2;		}	}}// 输出class Output implements Runnable {	Resource r;	// Object obj = new Object();	Output(Resource r) {		this.r = r;	}	public void run() {		while (true) {			synchronized (r) {				if (!r.flag)					try {						r.wait();					} catch (InterruptedException e) {					}				System.out.println(r.name + "....." + r.sex);				r.flag = false;				r.notify();			}		}	}}class ResourceDemo2 {	public static void main(String[] args) {		// 创建资源。		Resource r = new Resource();		// 创建任务。		Input in = new Input(r);		Output out = new Output(r);		// 创建线程,执行路径		Thread t1 = new Thread(in);		Thread t2 = new Thread(out);		// 开启线程		t1.start();		t2.start();	}}

版本3.0最终,修改优化后的:

class Resource { // 将资源私有化,提高安全性	private String name;	private String sex;	private boolean flag = false;	public synchronized void set(String name, String sex) { // 同步写在这,需要同步就是这个		if (flag)			try {				this.wait();			} catch (InterruptedException e) {			} // wait锁上的方法写在同步里		this.name = name;		this.sex = sex;		flag = true;		this.notify();	}	public synchronized void out() { // 同步写在这,需要同步就是这个		if (!flag)			try {				this.wait();			} catch (InterruptedException e) {			}		System.out.println(name + "...+...." + sex);		flag = false;		notify();	}}// 输入class Input implements Runnable {	Resource r;	// Object obj = new Object();	Input(Resource r) {		this.r = r;	}	public void run() {		int x = 0;		while (true) {			if (x == 0) {				r.set("mike", "nan");			} else {				r.set("丽丽", "女女女女女女");			}			x = (x + 1) % 2;		}	}}// 输出class Output implements Runnable {	Resource r;	// Object obj = new Object();	Output(Resource r) {		this.r = r;	}	public void run() {		while (true) {			r.out();		}	}}class ResourceDemo3 {	public static void main(String[] args) {		// 创建资源。		Resource r = new Resource();		// 创建任务。		Input in = new Input(r);		Output out = new Output(r);		// 创建线程,执行路径		Thread t1 = new Thread(in);		Thread t2 = new Thread(out);		// 开启线程		t1.start();		t2.start();	}}

生产者,消费者。

多生产者,多消费者的问题。 

多生产者,多消费者的时候

if判断标记,只有一次,会导致不该运行的线程运行了。出现了数据错误的情况。

出现生产一次消费多次,或者生产多次消费一次的现象,因为只判断一次,从wait那醒的,不再判断了。

可是还会出现全部等待的情况,即死锁的另外一种情况

while判断标记,解决了线程获取执行权后,是否要运行!

notify:只能唤醒一个线程,如果本方唤醒了本方,没有意义。而且while判断标记+notify会导致死锁。

notifyAll解决了本方线程一定会唤醒对方线程的问题。

class Resource {	private String name;	private int count = 1;	private boolean flag = false;	public synchronized void set(String name)//	{		while (flag)			try {				this.wait();			} catch (InterruptedException e) {			}// t1 t0 if的话 从这醒的,不再判断了		this.name = name + count;// 烤鸭1 烤鸭2 烤鸭3		count++;// 2 3 4		System.out.println(Thread.currentThread().getName() + "...生产者..."				+ this.name);// 生产烤鸭1 生产烤鸭2 生产烤鸭3		flag = true;		notifyAll();	}	public synchronized void out()// t3	{		while (!flag)			try {				this.wait();			} catch (InterruptedException e) {			} // t2 t3		System.out.println(Thread.currentThread().getName() + "...消费者........"				+ this.name);// 消费烤鸭1		flag = false;		notifyAll();	}}class Producer implements Runnable {	private Resource r;	Producer(Resource r) {		this.r = r;	}	public void run() {		while (true) {			r.set("烤鸭");		}	}}class Consumer implements Runnable {	private Resource r;	Consumer(Resource r) {		this.r = r;	}	public void run() {		while (true) {			r.out();		}	}}class ProducerConsumerDemo {	public static void main(String[] args) {		Resource r = new Resource();		Producer pro = new Producer(r);		Consumer con = new Consumer(r);		Thread t0 = new Thread(pro);		Thread t1 = new Thread(pro);		Thread t2 = new Thread(con);		Thread t3 = new Thread(con);		t0.start();		t1.start();		t2.start();		t3.start();	}}

多生产多消费

全唤醒都判断效率不高, 能不能只唤醒对方呢?

jdk1.5以后将同步和锁封装成了对象。

并将操作锁的隐式方式定义到了该对象中,

将隐式动作变成了显示动作。

Lock接口: 出现替代了同步代码块或者同步函数。将同步的隐式锁操作变成现实锁操作。

同时更为灵活。可以一个锁上加上多组监视器。

lock():获取锁。

unlock():释放锁,通常需要定义finally代码块中。

Condition接口:出现替代了Object中的wait notify notifyAll方法。

   将这些监视器方法单独进行了封装,变成Condition监视器对象。

   可以任意锁进行组合。

await();

signal();

signalAll();

import java.util.concurrent.locks.*; //如果不导包lock就写全称class Resource {	private String name;	private int count = 1;	private boolean flag = false;	// 创建一个锁对象。	Lock lock = new ReentrantLock(); // 是lock接口的子类,自定义锁	// lock 这个锁可以挂多个锁,通过已有的锁获取该锁上的监视器对象	// Condition con = lock.newCondition(); //lock.newCondition(),lock的方法	// 通过已有的锁获取两组监视器,一组监视生产者,一组监视消费者。	Condition producer_con = lock.newCondition();	Condition consumer_con = lock.newCondition();	public void set(String name)// t0 t1	{		lock.lock();		try {			while (flag)				// try{lock.wait();}catch(InterruptedException e){}// t1 t0				try {					producer_con.await();				} catch (InterruptedException e) {				}// t1 t0			this.name = name + count;// 烤鸭1 烤鸭2 烤鸭3			count++;// 2 3 4			System.out.println(Thread.currentThread().getName()					+ "...生产者5.0..." + this.name);// 生产烤鸭1 生产烤鸭2 生产烤鸭3			flag = true;			// notifyAll();			// con.signalAll();			consumer_con.signal();		} // 不准备处理异常,所以不需要catch		finally {			lock.unlock();		}	}	public void out()// t2 t3	{		lock.lock();		try {			while (!flag)				// try{this.wait();}catch(InterruptedException e){} //t2 t3				try {					cousumer_con.await();				} catch (InterruptedException e) {				} // t2 t3			System.out.println(Thread.currentThread().getName()					+ "...消费者.5.0......." + this.name);// 消费烤鸭1			flag = false;			// notifyAll();			// con.signalAll();			producer_con.signal();		} finally {			lock.unlock();		}	}}class Producer implements Runnable {	private Resource r;	Producer(Resource r) {		this.r = r;	}	public void run() {		while (true) {			r.set("烤鸭");		}	}}class Consumer implements Runnable {	private Resource r;	Consumer(Resource r) {		this.r = r;	}	public void run() {		while (true) {			r.out();		}	}}class ProducerConsumerDemo2 {	public static void main(String[] args) {		Resource r = new Resource();		Producer pro = new Producer(r);		Consumer con = new Consumer(r);		Thread t0 = new Thread(pro);		Thread t1 = new Thread(pro);		Thread t2 = new Thread(con);		Thread t3 = new Thread(con);		t0.start();		t1.start();		t2.start();		t3.start();	}}

wait 和 sleep 区别?

1,wait可以指定时间也可以不指定。 

   sleep必须指定时间。

2,在同步中时,对cpu的执行权和锁的处理不同。 他们都是冻结状态:释放执行权和资格

 wait:释放执行权,释放锁。释放锁别的才能进来

 sleep:释放执行权,不释放锁。因为他不需要别人叫

class Demo {	void show() {		synchronized (this)//		{			wait();// t0 t1 t2全活了		}	}	void method() {		synchronized (this)// t4		{			// wait();			notifyAll();		}// t4	}}

会出现全活状态,但是谁拿锁谁执行,不懂,参见多线程32

停止线程俩种方法:

1,stop方法。 强制性的,会出现危险,就像人跑的跑的没了

2,run方法结束。 很常用:

怎么控制线程的任务结束呢? 

任务中都会有循环结构,只要控制住循环就可以结束任务。

控制循环通常就用定义标记来完成。 

可是也有停不下来的时候,如同步时第一次读完标记,第二次就不读取标记了,结果全等待。

线程处于冻结状态(全部等待),不能用唤醒,因为notify必须同一个锁中。如何结束呢? 

可以使用interrupt()方法将线程从冻结状态强制恢复到运行状态中来,让线程具备cpu的执行资格。  

当强制动作会发生了InterruptedException,记得要处理 

class StopThread implements Runnable {	private boolean flag = true; // ture就转	public synchronized void run() {		while (flag)		// 为什么经常在run方法写循环,因为短了也不值得开启多线程。不写while(ture)		{			try {				wait();// t0 t1			} catch (InterruptedException e) {				System.out.println(Thread.currentThread().getName() + "....."						+ e);				flag = false; // 强制把你们恢复回来,再读到标记就会结束掉。wait是等待不是结束			}			System.out.println(Thread.currentThread().getName() + "......++++");		}	}	public void setFlag() {		flag = false; // 把标记置为假	}}class StopThreadDemo {	public static void main(String[] args) {		StopThread st = new StopThread();		Thread t1 = new Thread(st);		Thread t2 = new Thread(st);		t1.start();		t2.setDaemon(true); // setDameon是守护线程,可以理解为后台线程,你停我也停。前台必须手动结束		t2.start();		// 下边是主线程		int num = 1;		for (;;) // 无限循环		{			if (++num == 50) {				// st.setFlag(); 把标记置为假,结束while循环				t1.interrupt();				// t2.interrupt(); //验证守护线程				break; // 结束for循环			}			System.out.println("main...." + num);		}		System.out.println("over");	}}

join等方法

class Demo implements Runnable {	public void run() {		for (int x = 0; x < 50; x++) {			System.out.println(Thread.currentThread().toString() + "....." + x);			// tostring输出字符串,里面有名字、优先级(默认是5,常量是大写)			Thread.yield(); // 会成对的出现,你一下我一下		}	}}class JoinDemo {	public static void main(String[] args) throws Exception {		Demo d = new Demo();		Thread t1 = new Thread(d);		Thread t2 = new Thread(d);		t1.start();		t2.start();		// t2.setPriority(Thread.MAX_PRIORITY);		// t1.join();//t1线程要申请加入进来,运行(主线程释放执行权和资格)。t1结束主线程才能执行,t2.join也一样,临时加入一个线程运算时可以使用join方法		for (int x = 0; x < 50; x++) {			// System.out.println(Thread.currentThread()+"....."+x);		}	}}

面试题

面试题1

/*class Test implements Runnable

{

 public void run(Thread t)

 {}

}*/

//如果错误 错误发生在哪一行?错误在第一行,实现接口不重写方法,还是抽象类,应该被abstract修饰

面试题2:

三种开启线程匿名内部类的方法

class ThreadTest {	public static void main(String[] args) {		new Thread(new Runnable() {			public void run() {				System.out.println("runnable run");			}		}) { // 有复写了父类的run方法,输出的是子类			public void run() {				System.out.println("subThread run"); // 输出的是子类			}		}.start();		// 随时开辟一个线程,匿名内部类,这里有三个		new Thread() {			public void run() {				for (int x = 0; x < 50; x++) {					System.out.println(Thread.currentThread().getName()							+ "....x=" + x);				}			}		}.start();		for (int x = 0; x < 50; x++) {			System.out.println(Thread.currentThread().getName() + "....y=" + x);		}		Runnable r = new Runnable() {			public void run() {				for (int x = 0; x < 50; x++) {					System.out.println(Thread.currentThread().getName()							+ "....z=" + x);				}			}		};		new Thread(r).start();	}}

总结

1,进程和线程的概念。

 |--进程:

 |--线程:

2,jvm中的多线程体现。

 |--主线程,垃圾回收线程,自定义线程。以及他们运行的代码的位置。

3,什么时候使用多线程,多线程的好处是什么?创建线程的目的?

 |--当需要多部分代码同时执行的时候,可以使用。

4,创建线程的两种方式。★★★★★

 |--继承Thread

  |--步骤

 |--实现Runnable

  |--步骤

 |--两种方式的区别?

5,线程的5种状态。

 对于执行资格和执行权在状态中的具体特点。

 |--被创建:

 |--运行:

 |--冻结:

 |--临时阻塞:

 |--消亡:

6,线程的安全问题。★★★★★

 |--安全问题的原因:

 |--解决的思想:

 |--解决的体现:synchronized

 |--同步的前提:但是加上同步还出现安全问题,就需要用前提来思考。

 |--同步的两种表现方法和区别:

 |--同步的好处和弊端:

 |--单例的懒汉式。

 |--死锁。

7,线程间的通信。等待/唤醒机制。

 |--概念:多个线程,不同任务,处理同一资源。

 |--等待唤醒机制。使用了锁上的 wait notify notifyAll.  ★★★★★

 |--生产者/消费者的问题。并多生产和多消费的问题。  while判断标记。用notifyAll唤醒对方。 ★★★★★

 |--JDK1.5以后出现了更好的方案,★★★

  Lock接口替代了synchronized  

  Condition接口替代了Object中的监视方法,并将监视器方法封装成了Condition

  和以前不同的是,以前一个锁上只能有一组监视器方法。现在,一个Lock锁上可以多组监视器方法对象。

  可以实现一组负责生产者,一组负责消费者。

 |--wait和sleep的区别。★★★★★

8,停止线程的方式。

 |--原理:

 |--表现:--中断。

9,线程常见的一些方法。

 |--setDaemon()

 |--join();

 |--优先级

 |--yield();

 |--在开发时,可以使用匿名内部类来完成局部的路径开辟。 

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏Python研发

Memcached·Redis缓存的基本操作

Memcached 是一个高性能的分布式内存对象缓存系统,用于动态Web应用以减轻数据库负载。它通过在内存中缓存数据和对象来减少读取数据库的次数,从而提高动态、...

1474
来自专栏向治洪

java造成内存泄露原因

一、Java内存回收机制  不论哪种语言的内存分配方式,都需要返回所分配内存的真实地址,也就是返回一个指针到内存块的首地址。Java中对象是采用new或者反射的...

22010
来自专栏Java 源码分析

Java 虚拟机运行时数据区

运行时数据区: Java 虚拟机的运行时数据区按照大的可以分为线程独立使用的数据区,和所有线程共享的数据区。 一.线程独立使用数据区 1.程序计数器 程序计数器...

3364
来自专栏数据结构与算法

3185 队列练习 1

3185 队列练习 1 时间限制: 1 s 空间限制: 128000 KB 题目等级 : 黄金 Gold 题目描述 Description 给定一...

2986
来自专栏linux运维学习

linux学习第六十四篇:Shell脚本中的逻辑判断,文件目录属性判断, if特殊用法,case判断

Shell脚本中的逻辑判断 格式1:if 条件 ; then 语句; fi 格式2:if 条件; then 语句; else 语句; fi 格式3:if …; ...

3166
来自专栏技术小站

编程填空:第i位替换 编程填空:第i位取反 编程填空:左边i位取反

写出函数中缺失的部分,使得函数返回值为一个整数,该整数的第i位和m的第i位相同,其他位和n相同。

1981
来自专栏coding

redis列表list类型详解

4472
来自专栏yl 成长笔记

深刻理解反射(Reflection)

最近公司在搞自动化测试,由于版权问题,无法用 ’录制脚本‘ 进行,也就没法用 VS 自带的 UITest 框架(蛋疼), 所以只能开源的 FlaUI 框架来搞了...

1254
来自专栏python3

Python语句-if.....else......

似乎所有的条件语句都使用if.....else.....,它的作用可以简单地概括为非此即彼,满足条件A则执行A的语句,否则执行B语句,python的if.......

952
来自专栏java学习

Java每日一练(2017/7/7)

1 (单选题)有以下程序片段,下列哪个选项不能插入到行 1 。()。 1. 2.public class A{ 3.//do sth 4. } A publ...

36311

扫码关注云+社区