第八章 多线程
第八章——多线程
8.1 基本概念:程序,进程,线程
8.2 线程的创建和使用
package com.brook.java;
/**
* 多线程的创建,方式一:继承于Thread类
* 1.创建一个继承于Thread类的子类
* 2.重写Thread类的run() -->将此线程执行的操作声明在run()中
* 3. 创建Thread类的子类的对象
* 4、通过此对象调用start()方法
*
* @author brook
* @create 2021-04-08 22:01
*/
// 1.创建一个继承于Thread类的子类
class MyThread extends Thread{
// 重写Thread类的run()
@Override
public void run(){
for (int i = 0; i < 100; i++){
System.out.println("子线程:" + i + "############");
}
}
}
public class TestThread {
public static void main(String[] args) {
// 3. 创建Thread类的子类的对象
MyThread t1 = new MyThread();
// 4. 启动线程,并调用当前线程的run()方法
t1.start();
// t1.run() ,run()方法为普通方法,没有启动多线程
//说明:当main线程启动一个子线程Thread-0,主线程不会阻塞,会继续执行
for (int i = 0; i < 100; i++) {
System.out.println("主线程:" + i + "$$$$$$$$$$$$$$");
}
}
}
package com.brook.thread;
/**
* 创建多线程的方式二:实现Runnable接口
* 1. 创建一个实现Runnable接口的子类;
* 2.重写Runnable接口中的run方法;
* 3. 通过Thread类含参构造器创建线程对象;
* 4. 将Runnable接口的子类对象作为实际参数传递给Thread类的构造器中
* 5. 调用Thread类的start方法;
*
* 例子:遍历100以内的所有的偶数
*
* @author brook
* @create 2021-04-09 10:00
*/
public class TestThread1 {
public static void main(String[] args) {
// 3. 创建实现类的对象
MyThread1 mythread1 = new MyThread1();
// 4. 将此对象作为参数传递到Thread类的构造器中,创建Thread类的对象
Thread t1 = new Thread(mythread1);
// 5. 通过Thread类的对象调用start(): ①启动线程 ②调用当前线程的run()-->调用了runnable类型的target.run()方法
t1.setName("线程一:");
t1.start();
Thread t2 = new Thread(mythread1);
t2.setName("线程二:");
t2.start();
}
}
// 1.创建一个实现了Runnable接口的类
class MyThread1 implements Runnable{
// 2. 实现类去实现Runnable中的抽象方法: run()
@Override
public void run() {
for (int i = 0; i < 100; i++) {
if(i % 2 == 0)
System.out.println(Thread.currentThread().getName() + ":" + i);
}
}
}
package com.brook.exer;
/**
* 练习
* 创建两个分线程,让其中一个线程输出1-100之间的偶数,另一个线程输出1-100之间的奇数。
* @author brook
* @create 2021-04-08 22:37
*/
public class ThreadDemo {
public static void main(String[] args) {
// MyThread1 t1 = new MyThread1();
// MyThread2 t2 = new MyThread2();
// t1.start();
// t2.start();
// 创建Thread类的匿名子类的方式
new Thread(){
@Override
public void run() {
for (int i = 0; i < 100; i++) {
if(i % 2 == 0)
System.out.println(Thread.currentThread().getName() + ":" + i);
}
}
}.start();
new Thread(){
@Override
public void run() {
for (int i = 0; i < 100; i++) {
if(i % 2 != 0)
System.out.println(Thread.currentThread().getName() + ":" + i);
}
}
}.start();
}
}
class MyThread1 extends Thread{
@Override
public void run() {
for (int i = 0; i < 100; i++) {
if(i % 2 == 0)
System.out.println(Thread.currentThread().getName() + ":" + i);
}
}
}
class MyThread2 extends Thread{
@Override
public void run() {
for (int i = 0; i < 100; i++) {
if(i % 2 != 0)
System.out.println(Thread.currentThread().getName() + ":" + i);
}
}
}
package com.brook.thread;
/**
* 线程的优先级: 优先级高的线程被执行的概率更大,但不绝对
* 1.
* MAX_PRIORITY: 10
* MIN _PRIORITY: 1
* NORM_PRIORITY: 5 -->默认优先级
* 2.如何获取和设置当前线程的优先级:
* getpriority():获取线程的优先级
* setPriority(int p)∶设置线程的优先级
*
* @author brook
* @create 2021-04-09 0:22
*/
public class ThreadMethodTest {
public static void main(String[] args) {
//给分线程命名
HelloThread h1 = new HelloThread("子线程");
// 设置分线程的优先级
h1.setPriority(Thread.MAX_PRIORITY);
h1.start();
//给主线程命名
Thread.currentThread().setName("主线程");
// 设置主线程的优先级
Thread.currentThread().setPriority(Thread.MIN_PRIORITY);
for (int i = 0; i < 100; i++) {
if(i % 2 != 0)
System.out.println(Thread.currentThread().getName() + ":" + Thread.currentThread().getPriority() + ":" + i);
}
}
}
class HelloThread extends Thread{
public HelloThread(String name) {
super(name);
}
@Override
public void run() {
for (int i = 0; i < 100; i++) {
if(i % 2 == 0)
System.out.println(Thread.currentThread().getName() + ":" + Thread.currentThread().getPriority() + ":" + i);
}
}
}
例题:多窗口卖票
方式一
package com.brook.thread;
/**
* 例子:创建三个窗口卖票,总票数为100张
* 存在线程安全问题,待解决
* @author brook
* @create 2021-04-09 0:52
*/
public class WindowTest {
public static void main(String[] args) {
Window w1 = new Window("窗口一");
Window w2 = new Window("窗口二");
Window w3 = new Window("窗口三");
w1.start();
w2.start();
w3.start();
}
}
class Window extends Thread{
private static int ticket = 100;
public Window(String name) {
super(name);
}
@Override
public void run() {
while (true){
if (ticket > 0){
System.out.println(getName() + ":卖票,票号为:" + ticket);
ticket--;
}else {
break;
}
}
}
}
方式二
package com.brook.thread;
/**
* 例子:创建三个窗口卖票,总票数为100张: 方法二
* @author brook
* @create 2021-04-09 10:59
*/
public class WindowTest1 {
public static void main(String[] args) {
Window1 w = new Window1();
Thread t1 = new Thread(w);
Thread t2 = new Thread(w);
Thread t3 = new Thread(w);
t1.setName("NO. 1: ");
t2.setName("NO. 2: ");
t3.setName("NO. 3: ");
t1.start();
t2.start();
t3.start();
}
}
class Window1 implements Runnable{
private int ticket = 100;
@Override
public void run() {
while (true){
if (ticket > 0){
System.out.println(Thread.currentThread().getName() + ":卖票,票号为:" + ticket);
ticket--;
}else {
break;
}
}
}
}
比较创建线程的两种方式
开发中:优先选择实现Runnable接口的方式原因:
1.实现的方式没有类的单继承性的局限性
2.实现的方式更适合来处理多个线程有共享数据的情况。
联系: public class Thread implements Runnable
相同点: 两种方式都需要重写run(),将线程要执行的逻辑声明在run()中。
复习题
1. 谈谈你对程序、进程、线程的理解
程序:是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码,静态对象。
进程:是程序的一次执行过程,或是正在运行的一个程序。是一个动态的过程:有它自身的产生、存在和消亡的过程。——生命周期
- 如:运行中的QQ,运行中的MP3播放器
- 程序是静态的,进程是动态的
- 进程作为资源分配的单位,系统在运行时会为每个进程分配不同的内存区域
线程:进程可进一步细化为线程,是一个程序内部的一条执行路径。
- 若一个进程同一时间并行执行多个线程,就是支持多线程的
- 线程作为调度和执行的单位,每个线程拥有独立的运行栈和程序计数器(pc),线程切换的开销小
- 一个进程中的多个线程共享相同的内存单元/内存地址空间→它们从同一堆中分配对象,可以访问相同的变量和对象。这就使得线程间通信更简便、高效。但多个线程操作共享的系统资源可能就会带来安全的隐患。
2. 代码完成继承Thread的方式创建分线程,并遍历100以内的自然数。
public class TestThread{
public static void main(String[] args){
MyThread t = new MyThread("线程一");
t.start();
Thread.setName("线程二");
for (int i = 0; i < 100; i++)
System.out.println(Thread.currentThread.getName() + " : " + i);
}
}
class MyThread extends Thread{
public MyThread(String name){
super(name);
}
@Override
public void run(){
for (int i = 0; i < 100; i++)
System.out.println(getName() + " : " + i);
}
}
3. 代码完成实现Runnable 接口的方法创建分线程,并遍历100以内的自然数
public class TestThread{
public static void main(String[] args){
MyThread1 mythread1 = new MyThread();
Thread t1 = new Thread(mythread1);
Thread t2 = new Thread(mythread1);
t1.setName("线程一")
t2.setName("线程二")
t1.start();
t2.start();
}
}
class MyThread1 implements Runnable{
@Override
public void run(){
for (int i = 0; i < 100; i++)
System.out.println(Thread.currentThread().getName() + " : " + i);
}
}
4. 对比两种创建方式
开发中:优先选择实现Runnable接口的方式原因:
1.实现的方式没有类的单继承性的局限性
2.实现的方式更适合来处理多个线程有共享数据的情况。
联系: public class Thread implements Runnable
相同点: 两种方式都需要重写run(),将线程要执行的逻辑声明在run()中。
5. 说说你对IDEA中 Project和 Module的理解
IDEA中的project为最顶级的目录,下面包含众多module,project类似于eclipse中的workspace,而module相当于eclipse中的project;
8.3 线程的生命周期
8.4 线程的同步
/** * 1.问题:卖票过程中,出现了重票、错票-->出现了线程的安全问题 * 2.问题出现的原因:当某个线程操作车票的过程中,尚未操作完成时,其他线程参与进来,也操作车票 * 3.如何解决:当一个线程a在操作ticket的时候,其他线程不能参与进来。直到线程a操作完ticket时 * 线程才可以开始操作ticket。这种情况即使线程α出现了阻塞,也不能被改变。 * * @author brook * @create 2021-04-09 23:05 */public class TicketDemo { 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); t1.setName("window t1"); t2.setName("window t2"); t3.setName("window t3"); t1.start(); t2.start(); t3.start(); }}class Ticket implements Runnable{ private int ticket = 100; @Override public void run() { while (true){ if (ticket > 0){ try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + " ticket NO.: " + ticket--); }else break; } }}
使用同步代码块解决卖票中的线程安全问题
1. 实现Runnable接口的方法
/** * 方式一: 同步代码块 * * synchronized(同步监视器){ * //需要被同步的代码 * } * * 说明: 1.操作共享数据的代码,即为需要被同步的代码。 -->不能包含代码多了,也不能包含代码少了。 * 2.共享数据:多个线程共同操作的变量。比如: ticket就是共享数据。 * 3.同步监视器,俗称:锁。 任何一个类的对象,都可以充当锁。 * 要求:多个线程必须要共用同一把锁。 * 补充:在实现Runnable接口创建多线程的方式中,我们可以考虑使用this充当同步监视器。 * * * * @author brook * @create 2021-04-09 23:05 */public class TicketDemo { 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); t1.setName("window t1"); t2.setName("window t2"); t3.setName("window t3"); t1.start(); t2.start(); t3.start(); }}class Ticket implements Runnable { private int ticket = 100; Object obj = new Object(); @Override public void run() { while (true) { synchronized (obj) { // 此处可以用this,synchronized(this),this代表当前对象 if (ticket > 0) { try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + " ticket NO.: " + ticket--); } else break; } } }}
2. 继承Thread类的方式
/** * 例子: 创建三个窗口卖票,总票数为100张.使用继承Thread类的方式 * * 使用同步代码块解决继承Thread类的方式的线程安全问题 * * 补充: 在继承Thread类创建多线程的方式中,慎用this充当同步监视器。考虑使用当前类充当同步监视器 * * @author brook * @create 2021-04-10 10:28 */public class TicketDemo1 { public static void main(String[] args) { Ticket1 t1 = new Ticket1(); Ticket1 t2 = new Ticket1(); Ticket1 t3 = new Ticket1(); t1.setName("window 1"); t2.setName("window 2"); t3.setName("window 3"); t1.start(); t2.start(); t3.start(); }}class Ticket1 extends Thread { private static int ticket = 100; private static Object obj = new Object(); // 锁 @Override public void run() { while (true) { // synchronized (Ticket1.class) synchronized (obj) { // 线程同步, 此处不能用this,因为对象不唯一 if (ticket > 0) { try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + " ticket NO.: " + ticket--); }else break; } } }}
使用同步方法解决卖票中的线程安全问题
1. 实现Runnable接口的方法
/** * * 使用同步方法解决实现Runnable接口的线程安全问题 * * @author brook * @create 2021-04-10 11:06 */public class TicketDemo2 { public static void main(String[] args) { Ticket2 t = new Ticket2(); Thread t1 = new Thread(t); Thread t2 = new Thread(t); Thread t3 = new Thread(t); t1.setName("window t1"); t2.setName("window t2"); t3.setName("window t3"); t1.start(); t2.start(); t3.start(); }}class Ticket2 implements Runnable { private int ticket = 100; // 同步方法 private synchronized void show() { if (ticket > 0) { try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + " ticket NO.: " + ticket--); } } @Override public void run() { // 同步监视器this while (true) { show(); if (ticket <= 0) break; } }}
2. 继承Thread类
/** * * 例子: 创建三个窗口卖票,总票数为100张.使用继承Thread类的方式 * * 使用同步方法解决继承Thread类的线程安全问题 * * * @author brook * @create 2021-04-10 12:04 */public class TicketDemo3 { public static void main(String[] args) { Ticket3 t = new Ticket3(); Thread t1 = new Thread(t); Thread t2 = new Thread(t); Thread t3 = new Thread(t); t1.setName("window t1"); t2.setName("window t2"); t3.setName("window t3"); t1.start(); t2.start(); t3.start(); }}class Ticket3 extends Thread { private static int ticket = 100; // 同步方法 private static synchronized void show() { // //private synchronized void show() { //同步监视器: t1,t2,t3。此种解决方式是错误的{ if (ticket > 0) { try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + " ticket NO.: " + ticket--); } } @Override public void run() { // 同步监视器this while (true) { show(); if (ticket <= 0) break; } }}
线程安全的单例模式——懒汉式
/** * @author brook * @create 2021-04-11 9:57 */public class SingletonTest { public static void main(String[] args) { Bank b1 = Bank.getInstance(); Bank b2 = Bank.getInstance(); System.out.println(b1 == b2); }}class Bank { private Bank(){} private static Bank instance = null; // 同步方法 public static synchronized Bank getInstance() { if (instance == null) instance = new Bank(); return instance; } // 更加有效率的写法// public static Bank getInstance() {// if (instance == null) {// synchronized (Bank.class) {// if (instance == null)// instance = new Bank();// }// }// return instance;// }}
死锁演示
/** * @author brook * @create 2021-04-12 11:03 */public class DeadLockTest { public static void main(String[] args) { final StringBuffer s1 = new StringBuffer(); final StringBuffer s2 = new StringBuffer(); new Thread() { public void run() { synchronized (s1) { s1.append('A'); s2.append('1'); try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } synchronized (s2) { s1.append('B'); s2.append('2'); System.out.println(s1); System.out.println(s2); } } } }.start(); new Thread() { public void run() { synchronized (s2) { s1.append('C'); s2.append('3'); try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } synchronized (s1) { s1.append('D'); s2.append('4'); System.out.println(s1); System.out.println(s2); } } } }.start(); }}
使用lock锁解决卖票问题
import java.util.concurrent.locks.ReentrantLock;/** * 解决线程安全问题的方式三: Lock锁--- JDK5.0 新增 * @author brook * @create 2021-04-12 17:11 */public class LockTest { public static void main(String[] args) { Ticket4 t = new Ticket4(); Thread t1 = new Thread(t); Thread t2 = new Thread(t); Thread t3 = new Thread(t); t1.setName("window t1"); t2.setName("window t2"); t3.setName("window t3"); t1.start(); t2.start(); t3.start(); }}class Ticket4 implements Runnable { private int ticket = 100; //1.实例化ReentrantLock private ReentrantLock lock = new ReentrantLock(); @Override public void run() { while (true) { try { // 2. 调用锁定方法lock() lock.lock(); if (ticket > 0) { try { System.out.println(Thread.currentThread().getName() + " ticket NO.: " + ticket--); Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } } }finally { // 3. 调用解锁方法unlock() lock.unlock(); } } }}
面试题:synchronized 与lock的异同?
实现Runnable接口的方式
package exercise;/** * 银行有一个账户。 * 有两个储户分别向同一个账户存3000元,每次存1000,存3次。每次存完打印账户余额。 * 分析: * 1.是否是多线程问题?是,两个储户线程 * 2.是否有共享数据?有,账户(或账户余额) * 3.是否有线程安全问题?有 * 4.需要考虑如何解决线程安全问题?同步机制:有三种方式。 * * @author brook * @create 2021-04-12 22:47 */public class AccountTest { public static void main(String[] args) { Account a = new Account(); Thread t1 = new Thread(a); Thread t2 = new Thread(a); t1.setName("person 1"); t2.setName("person 2"); t1.start(); t2.start(); }}// 实现的方式class Account implements Runnable { private int balance; // 同步方法 @Override public synchronized void run() { for (int i = 0; i < 3; i++) { try { Thread.sleep(200); balance += 1000; System.out.println(Thread.currentThread().getName() + " : " + balance); } catch (InterruptedException e) { e.printStackTrace(); } } }}
继承Thread类的方式
package exercise;/** * @author brook * @create 2021-04-12 23:41 */public class AccountTest1 { public static void main(String[] args) { Account1 acc = new Account1(0); Customer c1 = new Customer(acc); Customer c2 = new Customer(acc); c1.setName("person 1"); c2.setName("person 2"); c1.start(); c2.start(); }}class Account1 { private int balance; public Account1(int balance) { this.balance = balance; } public synchronized void deposit(int money) { if (money > 0){ try { Thread.sleep(200); balance += money; System.out.println(Thread.currentThread().getName() + " : " + balance); } catch (InterruptedException e) { e.printStackTrace(); } } }}// 继承Thread类的方式class Customer extends Thread { private Account1 acc; public Customer(Account1 acc) { this.acc = acc; } @Override public void run() { for (int i = 0; i < 3; i++) { acc.deposit(1000); } }}
交替存钱,使用wait()和notify()方法
package exercise;/** * 银行有一个账户。 * 有两个储户分别向同一个账户存3000元,每次存1000,存3次。每次存完打印账户余额。 * 分析: * ******交替存钱的方式********** * * @author brook * @create 2021-04-12 22:47 */public class AccountTest { public static void main(String[] args) { Account a = new Account(); Thread t1 = new Thread(a); Thread t2 = new Thread(a); t1.setName("person 1"); t2.setName("person 2"); t1.start(); t2.start(); }}// 实现Rnnable接口的方式class Account implements Runnable { private int balance = 0; //同步代码块 @Override public void run() { for (int i = 0; i < 3; i++) { synchronized (this) { notify(); try { balance += 1000; System.out.println(Thread.currentThread().getName() + " deposit $1000,balance is " + balance); Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } try { wait(); } catch (InterruptedException e) { e.printStackTrace(); } } } }}
8.5 线程的通信
面试题:比较sleep()和wait()方法的异同?
1.相同点:一旦执行方法,都可以使得当前的线程进入阻塞状态。|
2.不同点:
1)两个方法声明的位置不同: Thread类中声明sleep() , 0bject类中声明wait();
2)调用的要求不同: sleep()可以在任何需要的场景下调用。wait()必须使用在同步代码块或同步方法中;
3)关于是否释放同步监视器:如果两个方法都使用在同步代码块或同步方法中,sleep()不会释放锁,wait()会释放锁;
package threadstudy;/** * 经典例题: 生产者/消费者问题 * * @author brook * @create 2021-04-13 16:59 */public class ProducerConsumer { public static void main(String[] args) { Clerk clerk = new Clerk(); Thread p = new Thread(new Producer(clerk)); Thread c = new Thread(new Consumer(clerk)); p.setName("producer"); c.setName("customer"); p.start(); c.start(); }}class Clerk { private int product = 0; //生产产品 public synchronized void produce() { if (product < 20) { product++; System.out.println(Thread.currentThread().getName()+": "+product); notifyAll(); } else { try { wait(); } catch (InterruptedException e) { e.printStackTrace(); } } } //消费产品 public synchronized void consume() { if (product > 0) { System.out.println(Thread.currentThread().getName()+": "+product); product--; notifyAll(); } else { try { wait(); } catch (InterruptedException e) { e.printStackTrace(); } } }}// 生产者class Producer implements Runnable { private Clerk clerk; public Producer(Clerk clerk) { this.clerk = clerk; } @Override public void run() { while (true) { try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } clerk.produce(); } }}//消费者class Consumer implements Runnable { private Clerk clerk; public Consumer(Clerk clerk) { this.clerk = clerk; } @Override public void run() { while (true) { try { Thread.sleep(200); } catch (InterruptedException e) { e.printStackTrace(); } clerk.consume(); } }}
8.6 JDK5.0新增线程创建方式
package threadstudy;import java.util.concurrent.Callable;import java.util.concurrent.ExecutionException;import java.util.concurrent.FutureTask;/** * 创建线程的方式三:实现callabLe接口。--- JDK 5.0新增 * * 如何理解实现Callable接口的方式创建多线程比实现Runnable接口创建多线程方式强大? * 1. call()可以有返回值的。 * 2. call()可以抛出异常,被外面的操作捕获,获取异常的信息 * 3. Callable是支持泛型的 * * @author brook * @create 2021-04-13 22:35 */public class ThreadNew { public static void main(String[] args) { // 3. 创建callable接口实现类的对象 NumThread numThread = new NumThread(); // 4. 将此Callable接口实现类的对象作为传递到FutureTask构造器中,创建FutureTask的对象 FutureTask futureTask = new FutureTask(numThread); // 5. 将FutureTask的对象作为参数传递到Thread类的构造器中,创建Thread对象,并调用start()方法 new Thread(futureTask).start(); try { // 6. 获取Callable中call方法的返回值 // get()返回值即为FutureTask构造器参数callable实现类重写的call()的返回值。 Object sum = futureTask.get(); System.out.println("sum is : " + sum); } catch (InterruptedException e) { e.printStackTrace(); } catch (ExecutionException e) { e.printStackTrace(); } }}// 1. 创建一个实现Callable的实现类class NumThread implements Callable { // 2. 实现call方法,将此线程需要执行的操作声明在call()中 @Override public Object call() throws Exception { int sum = 0; for (int i = 1; i <= 100 ; i++) { if (i % 2 == 0){ System.out.println(i); sum += i; } } return sum; }}
package threadstudy;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;/** * 创建线程的方式四:使用线程池 * * 好处: * 1.提高响应速度(减少了创建新线程的时间) * 2.降低资源消耗(重复利用线程池中线程,不需要每次都创建>) * 3.便于线程管理 * corePooLsize:核心池的大小 * maximumPooLsize:最大线程数 * keepAliveTime:线程没有任务时最多保持多长时间后会终止 * * @author brook * @create 2021-04-13 23:23 */public class ThreadPool { public static void main(String[] args) { // 1.提供指定线程数量的线程池 ExecutorService service = Executors.newFixedThreadPool(10);// ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;// service1.setCorePoolSize(15);// service1.setKeepAliveTime(); // 2. 执行指定的线程的操作,需要提供实现Runnable接口或callable接口实现类的对象 service.execute(new NumberThread()); //适合使用于Runnable service.execute(new NumberThread1()); //适合使用于Runnable // 3. 关闭连接池 service.shutdown();// service.submit(); //适合使用于Callable }}class NumberThread implements Runnable { //输出偶数 @Override public void run() { for (int i = 0; i <= 100; i++) { if (i % 2 ==0) System.out.println(Thread.currentThread().getName() + " : " + i); } }}class NumberThread1 implements Runnable { // 输出奇数 @Override public void run() { for (int i = 0; i <= 100; i++) { if (i % 2 !=0) System.out.println(Thread.currentThread().getName() + " : " + i); } }}
复习题
1.画图说明线程的生命周期,以及各状态切换使用到的方法等状态,方法。
2.同步代码块中涉及到同步监视器和共享数据,谈谈你对同步监视器和共享数据的理解,以及注意点。
3.sleep()和wait()的区别?
1.相同点:一旦执行方法,都可以使得当前的线程进入阻塞状态。|
2.不同点:
1)两个方法声明的位置不同: Thread类中声明sleep() , 0bject类中声明wait();
2)调用的要求不同: sleep()可以在任何需要的场景下调用。wait()必须使用在同步代码块或同步方法中;
3)关于是否释放同步监视器:如果两个方法都使用在同步代码块或同步方法中,sleep()不会释放锁,wait()会释放锁;
4. 写一个线程安全的懒汉式
class Bank { private static Bank instance; private Bank() {} public static Bank getInstance() { if (instance == null) { synchronized(Bank.class) { if (instance == null) instance = new Bank(); } } return instance; }}
5. 创建多线程有哪几种方式?
1)继承Thread类
2)实现Runna接口
3)实现Callable接口
4)使用线程池