其他分享
首页 > 其他分享> > 第十五章、多线程

第十五章、多线程

作者：互联网

多线程

1. 进程与线程初识

1.1 进程

1.2 线程

1.3 线程和进程的区别

2. 多线程实现方案

2.1 继承Thread类实现

  1. 实现步骤

    • 自定义类线程类(例：MyThread)，继承Thread类

    • MyThread重写run方法

    • 创建线程对象

    • 启动线程

  2. 线程方法

    run()				线程执行和普通方法一致
start()				开启线程
setName()			设置当前线程名
getName()			获取当前线程名
currentThread() 	获取当前主线程

  3. 代码示例

    public class TestThread extends Thread {//自定义类继承Thread类
    //run()方法里是线程体
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(this.getName() + ":" + i);//getName()方法是返回线程名称
        }
    }
 
    public static void main(String[] args) {
        TestThread thread1 = new TestThread();//创建线程对象
        thread1.setName("线程1")//设置线程名称 
        thread1.start();//启动线程
        TestThread thread2 = new TestThread();
        thread2.setName("线程2")
        thread2.start();
    }
}

2.2 Runnable接口实现

  1. 实现步骤

    • 自定义类线程类(例：MyRunnable)，实现Runnable接口

    • MyRunnable重写run方法

    • 创建线程对象

    • 启动线程

  2. 线程方法：和继承Thread类实现多线程一致

  3. 代码示例

    public class TestThread2 implements Runnable {//自定义类实现Runnable接口；
    //run()方法里是线程体；
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + ":" + i);
        }
    }
    public static void main(String[] args) {
        //创建线程对象，把实现了Runnable接口的对象作为参数传入；
        Thread thread1 = new Thread(new TestThread2());
        thread1.setName("线程1")//设置线程名称 
        thread1.start();//启动线程；
        Thread thread2 = new Thread(new TestThread2());
        thread2.setName("线程1")//设置线程名称 
        thread2.start();
    }
}

3. 线程调度和线程控制

4. 线程生命周期

图11-4 线程生命周期图.png

5. 线程同步

6. 死锁

7. 线程通信(生产者消费者模型)

7.1 相关概念

图11-17 生产者消费者示意图.png

7.2 相关方法

表11-2 线程通信常用方法.png

7.3 代码实现

// 生产对象
package demo9;

public class Book {

	private String name;
	private int price;

	// 如果为true说明仓库里面有书，如果为false说明仓库里面没有书
	// 如果有书，就通知消费者去消费
	// 如果没有书，就通知生产者取生产
	public boolean flag;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getPrice() {
		return price;
	}

	public void setPrice(int price) {
		this.price = price;
	}

}

// 消费者
package demo9;

public class Consumption implements Runnable {

	private Book book;

	public Consumption(Book book) {
		this.book = book;
	}

	@Override
	public void run() {

		// 为了模拟一直消费
		while (true) {
			synchronized (book) {
				if (!book.flag) {
					try {
						book.wait(); // 等待，如果生产者那边有书就继续往下走
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				} else {
					System.out.println(
							Thread.currentThread().getName() + "买了" + book.getName() + "价格是" + book.getPrice());
					book.flag = false;
					book.notify();
				}
			}
		}
	}
}

// 生产者
package demo9;

public class Production implements Runnable {

	private Book book;

	int num = 0;

	public Production(Book book) {
		this.book = book;
	}

	@Override
	public void run() {
		// 为了模拟一直生产
		while (true) {
			synchronized (book) {
				if (book.flag) {
					try {
						book.wait(); // 如果有书，生产者线程就进入等待，不生产了
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
				if (num % 2 == 0) {
					book.setName("不能承受生命之轻");
					book.setPrice(123);
					System.out.println(
							Thread.currentThread().getName() + "生产了" + book.getName() + "价格是" + book.getPrice());
				} else {
					book.setName("作为表象与意志的世界");
					book.setPrice(99);
					System.out.println(
							Thread.currentThread().getName() + "生产了" + book.getName() + "价格是" + book.getPrice());
				}
				num++;
				book.flag = true;
				book.notify(); // 唤醒消费线程

			}
		}

	}

}

// 实现类
package demo9;

/*
 * 生产者：
 * 		先看是否有数据，有就等待，没有就生产，生产完成后就通知消费者过来消费
 * 消费者：
 * 		先看是否有数据，悠久消费，没有就等待，通知生产者过来生产
 * 
 * 		
 * 		等待唤醒
 * 			wait()		等待
 * 			notify()    唤醒单个线程
 * 			ntifyAll()	唤醒所有等待的线程
 * 		
 * 		wait和sleep的区别？
 * 			wait等待需要被唤醒
 * 			sleep休眠，一定时间会自动苏醒
 */
public class TestThread {
	public static void main(String[] args) {

		Book b = new Book();

		Consumption c = new Consumption(b);
		Production p = new Production(b);

		Thread t1 = new Thread(c, "消费者"); // 消费者
		Thread t2 = new Thread(p, "生产者"); // 生产者

		t1.start();
		t2.start();

	}
}

8.线程组

9. 线程池

9.1 线程池的优势

9.2 线程池流程

img

9.3 Executors实现线程池

方法名 功能
newFixedThreadPool(int nThreads) 创建固定大小的线程池
newSingleThreadExecutor() 创建只有一个线程的线程池
newCachedThreadPool() 创建一个不限线程数上限的线程池，任何提交的任务都将立即执行

10. 定时器

标签：Thread,void,book,线程,第十五章,new,多线程,public
来源： https://www.cnblogs.com/borntodie/p/14141114.html