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();

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

来自为知笔记(Wiz)

时间： 2024-08-27 06:12:35

7：多线程的相关文章

Java多线程学习（吐血超详细总结）

林炳文Evankaka原创作品.转载请注明出处http://blog.csdn.net/evankaka 目录(?)[-] 一扩展javalangThread类二实现javalangRunnable接口三Thread和Runnable的区别四线程状态转换五线程调度六常用函数说明使用方式为什么要用join方法七常见线程名词解释八线程同步九线程数据传递本文主要讲了java中多线程的使用方法.线程同步.线程数据传递.线程状态及相应的一些线程函数用法.概述等. 首先讲一下进程和线程

Spring多线程

Spring是通过TaskExecutor任务执行器来实现多线程和并发编程的.使用ThreadPoolTaskExecutor可实现一个基于线程池的TaskExecutor.而实际开发中任务一般是非阻碍的,即异步的,所以我们要在配置类中通过@EnableAsync开启对异步的支持,并通过在实际执行的Bean的方法中使用@Async注解来声明其是一个异步任务. 实例代码: (1)配置类 package com.lwh.highlight_spring4.ch3.taskexecutor; /**

python进阶学习（一）--多线程编程

1. 多线程概念:简单地说操作系统可以同时执行多个不用程序.例如:一边用浏览器上网,一边在听音乐,一边在用笔记软件记笔记. 并发:指的是任务数多余cpu核数,通过操作系统的各种任务调度算法,实现用多个任务"一起"执行(实际上总有一些任务不在执行,因为切换任务的熟度相当快,看上去一起执行而已) 并行:指的是任务数小于等于CPU核数,即任务真的是一起执行的. 2. 线程概念:线程是进程的一个实体,是CPU调度和分派的基本单位. threading--单线程执行: 1 import ti

多线程的实现及其安全问题

一.进程和线程概述 1.进程:进程是一个具有独立功能的程序关于某个数据集合的一次运行活动,简单来说开启一个程序就开启了一个进程: 如果开启多个进程,它们之间是由于CPU的时间片在相互的切换: 2.线程:开启一个进程的一个任务,对于多线程:每一个线程都在争夺CPU的执行权(CPU的执行权具有随机性): 如果一个程序的执行路径有多条,那么该线程是多线程;反之,就单线程线程:线程是依赖于进程存在的! 3.Jvm是多线程 -- 至少开启了两条线程 main方法主线程 gc() 垃圾回收线程二.多线程

多线程和多进程的区别与联系

1.单进程单线程:一个人在一个桌子上吃菜.2.单进程多线程:多个人在同一个桌子上一起吃菜.3.多进程单线程:多个人每个人在自己的桌子上吃菜. 多线程的问题是多个人同时吃一道菜的时候容易发生争抢,例如两个人同时夹一个菜,一个人刚伸出筷子,结果伸到的时候已经被夹走菜了...此时就必须等一个人夹一口之后,在还给另外一个人夹菜,也就是说资源共享就会发生冲突争抢. 1.对于 Windows 系统来说,[开桌子]的开销很大,因此 Windows 鼓励大家在一个桌子上吃菜.因此 Windows 多线程学习重点

Python有了asyncio和aiohttp在爬虫这类型IO任务中多线程/多进程还有存在的必要吗？

最近正在学习Python中的异步编程,看了一些博客后做了一些小测验:对比asyncio+aiohttp的爬虫和asyncio+aiohttp+concurrent.futures(线程池/进程池)在效率中的差异,注释:在爬虫中我几乎没有使用任何计算性任务,为了探测异步的性能,全部都只是做了网络IO请求,就是说aiohttp把网页get完就程序就done了. 结果发现前者的效率比后者还要高.我询问了另外一位博主,(提供代码的博主没回我信息),他说使用concurrent.futures的话因为我全

多线程（一）

这边来谈谈java中,我对对多线程的理解在了解多线程前,先说说进程. 进程就是正在运行的应用程序. 当你打开任务管理器的时候,你就会发现很多的进程. 而我们要说的线程,就是依赖于进程而存在的,一个进程可以开启多个线程. Thread类说到线程,就必须来说说Thread类. Thread类是说有线程的父类.具体请参见api 线程的创建以及执行(图解如下) 继承Thread类,或者实现rennable接口. 当继承了父类后,需要重写父类的run方法,这个run方法里面就写你要执行的代码,当这个

多线程下的单例-double check

话不多说直接上代码: public sealed class Singleton { private static Singleton _instance = null; // Creates an syn object. private static readonly object SynObject = new object(); Singleton() { } public static Singleton Instance { get { // Double-Checked Lockin

笔记：多线程

多线程程序在较低的层次上扩展了多任务的概念:一个程序同时执行多个任务,通常每个任务称为一个线程(thread),他是线程控制的简称,可以同时运行一个以上线程的程序称为多线程程序(multithreaded):多线程和多进程有哪些区别呢,本质的区别在于每个进程拥有自己的一整套变量,而线程则是共享数据,Java中启动一个线程的代码如下: // 线程任务的具体实现接口 ????public interface Runnable { public abstract void run(); ????} /

多线程

1.线程的概念? 多线程,就类似与操作系统中的多进程.简单的讲,就是可以同时并发执行多个任务,处理多件事情.这与我们经常所谓的边唱边跳,边说边做事一个道理.? 线程是一个轻量级的进程,一个进程中可以分为多个线程. 比起进程,线程所耗费的系统资源更少,切换更加容易 /* * 进程是操作系统中的一个任务,一个程序启动运行,就会创建 * 一个(或多个)进程. * 线程是轻量级的进程.进程会有自己独立的内存空间与资源.一个进程 * 下会存在一个(或多个)线程.线程为进程的执行单元.线程本身不含有 *