多线程 java 同步、锁、 synchronized 、 Thread 、 Runnable

线程

1 线程概述

1.1 什么是线程

v 线程是程序执行的一条路径, 一个进程中可以包含多条线程

v 一个应用程序可以理解成就是一个进程

v 多线程并发执行可以提高程序的效率, 可以同时完成多项工作

1.2 多线程应用场景

VNC同时共享屏幕给多个电脑
迅雷开启多条线程一起下载
QQ同时和多个人一起视频
服务器同时处理多个客户端请求

1.3并行和并发的区别

并行就是两个任务同时运行，就是甲任务进行的同时，乙任务也在进行。(需要多核CPU)
并发是指两个任务都请求运行，而处理器只能按受一个任务，就把这两个任务安排轮流进行，由于间时间隔较短，使人感觉两个任务都在运行（画图-任务调度）。

1.4 Java程序运行原理

Java命令会启动java虚拟机(JVM)，等于启动了一个应用程序，也就是启动了一个进程。
该进程会自动启动一个 “主线程” ，然后主线程去调用某个类的 main 方法
一个应用程序有且只有一个主线程,程序员不能New主线程，可以New子线程。

1.5 JVM启动的是多线程吗？

JVM启动至少启动了垃圾回收线程和主线程，所以是多线程的。
main方法的代码执行的位置就是在主线程(路径)
一个进程有多个线程
finalize()这个方法在子线程(垃圾回收线程)执行

public class Demo01 {

public static void main(String[] args) {

/*JVM的启动是多线程的吗？【面试题】*/

System.out.println("AAAAA");

System.out.println("BBBBB");

System.out.println("CCCCC");

System.out.println("DDDDD");

//打印线程名称

System.out.println(Thread.currentThread());//主线程

for(int i = 0;i<2;i++){

new Student();

System.gc();//启动垃圾回收

}

class Student{

//被垃圾回收器回收时，会调用

//对象从内存释放时，会调用

@Override

protected void finalize() throws Throwable {

// TODO Auto-generated method stub

System.out.println("student 被回收了...");

//打印线程名称

System.out.println(Thread.currentThread());//子线程

}

2 Java中线程的实现方式

2.1方式一、继承Thread

使用步骤：

1．定义类继承Thread

2．重写run方法

3．把新线程要做的事写在run方法中

4．创建线程对象

5．开启新线程, 内部会自动执行run方法

代码：

public class Demo01 {

public static void main(String[] args) {

/*主线程，程序员不能创建，程序员只能创建子线程*/

//1.创建子线程对象

MyThread t1 = new MyThread();

/**不能通过下面的方式来执行任务

* 因为这种试的任务是在主线程执行的*/

//t1.run();

//2.正确的执行任务的方式,调用start,内部会开启新线程，调用run方法

t1.start();

//3.再创建子线程

MyThread t2 = new MyThread();

t2.start();

//4.循环创建子线程

for(int i=0;i<10;i++){

MyThread th = new MyThread();

th.start();

}

class MyThread extends Thread{

@Override

public void run() {

System.out.println("银行信用卡还款短信任务..." + Thread.currentThread());

System.out.println("线程名称" + this.getName());

}

2.2方式二、实现Runnable接口

实现步骤：

1.定义类实现Runnable接口

2.实现run方法

3.把新线程要做的事写在run方法中

4.创建自定义的Runnable的子类对象,创建Thread对象传入Runnable

5.调用start()开启新线程, 内部会自动调用Runnable的run()方法

代码：

public class Demo01 {

public static void main(String[] args) {

/* 线程实现的方式 (2) - 定义类实现Runnable接口

//1.创建runable对象

BankTask task = new BankTask();

//2.创建Thread对象

Thread t1 = new Thread(task);

//3.启动线程

t1.start();

//4.再开启2个线程

Thread t2 = new Thread(task);

t2.start();

Thread t3 = new Thread(task);

t3.start();

}

class BankTask implements Runnable{

@Override

public void run() {

// TODO Auto-generated method stub

System.out.println("银行储蓄卡自动结算利息任务..." + Thread.currentThread());

//System.out.println("线程名称:" + this.getName());

System.out.println("线程名称:" +Thread.currentThread().getName());

}

2.3两种方式的区别

区别:

继承Thread : 由于子类重写了Thread类的run(), 当调用start()时直接找子类的run()方法
实现Runnable : 构造函数中传入了Runnable的引用, 有个成员变量记住了它, 调用run()方法时内部判断成员变量Runnable的引用是否为空。

继承Thread

好处是:可以直接使用Thread类中的方法,代码简单
弊端是:如果已经有了父类,就不能用这种方法

实现Runnable接口

好处是:即使自己定义的线程类有了父类也没关系,因为有了父类也可以实现接口,代码更灵活
弊端是:不能直接使用Thread中的方法,需要先获取到线程对象后,才能得到Thread的方法,代码复杂

2.4 匿名内部类实现线程的两种方式

public static void main(String[] args) {

//匿名内部类实现线程的两种方式

/*Thread t1 = new Thread(){

@Override

public void run() {

System.out.println("任务1...." + Thread.currentThread());

}

};

t1.start();*/

new Thread(){

public void run() {

System.out.println("任务1...." + Thread.currentThread());

};

}.start();

/*Thread t2 = new Thread(new Runnable() {

@Override

public void run() {

System.out.println("任务2...." + Thread.currentThread());

}

});

t2.start();*/

new Thread(new Runnable() {

@Override

public void run() {

System.out.println("任务2...." + Thread.currentThread());

}

}).start();

}

2.5 获取线程名字和设置名字

通过Thread的getName()方法获取线程对象的名字
通过setName(String)方法可以设置线程对象的名字
通过构造函数可以传入String类型的名字
每个线程系统都会默认分配个名字,主线程：main,子线程thread-0 ....

public class Demo01 {

public static void main(String[] args) {

/* 获取线程名字和设置名字(掌握)

//1.获取主线程对象

Thread mainThread = Thread.currentThread();

System.out.println(Thread.currentThread());

System.out.println(mainThread);

System.out.println("名称:" + mainThread.getName());

//2.设置线程的名称

mainThread.setName("主线程");

System.out.println(mainThread);

//3.设置子线程的名称

MyThread myThread = new MyThread("子线程1");

myThread.start();

}

class MyThread extends Thread{

public MyThread(String name) {

super(name);

}

@Override

public void run() {

System.out.println("银行代发工资任务..." + Thread.currentThread());

}

2.6 获取当前线程的对象

Thread.currentThread()方法用于获取当前线程对象
在不同的方法中，获取的线程对象名称是有可能不一样的
在main中获取的是主线程对象
在子线程的run方法中获取的是子线程对象

public class Demo01 {

public static void main(String[] args) {

//获取当前线程的对象(掌握)

Thread mainThread = Thread.currentThread();

mainThread.setName("主线程");

//打印主线程对象

System.out.println(mainThread);

//打印主线程对象类名

System.out.println(mainThread.getClass());

System.out.println("================");

//开启子线程

MyThread mt = new MyThread();

mt.start();

}

class MyThread extends Thread{

@Override

public void run() {

System.out.println("任务...");

Thread subThread = Thread.currentThread();

//打印子线程对象

System.out.println(subThread);

//打印子线程对象类名

System.out.println(subThread.getClass().getName());

}

3 线程的其它方法

3.1 线程休眠(掌握)

Thread.sleep(毫秒), 控制当前线程休眠若干毫秒
1秒= 1000毫秒
1秒 = 1000毫秒* 1000微妙 * 1000纳秒（1000000000 ）

主线程休眠

/*** 主线程休眠 */

public static void test1() {

for(int i=0;i<10;i++){

System.out.println(i);

//休眠【暂停】

try {

Thread.sleep(1000);//主线程休眠

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

System.out.println("AAAAAAAAAAAAAAAAAA");

}

子线程休眠

/**

* 子线程休眠

public static void test2() {

//子线程休眠

new Thread(){

public void run() {

for(int i=0;i<10;i++){

System.out.println(Thread.currentThread() + " " + i);

//休眠

try {

Thread.sleep(1000);

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

};

}.start();

System.out.println("AAAAAAAAAAAAAAAA");

}

3.2 守护线程(了解)

setDaemon(), 设置一个线程为守护线程, 该线程不会单独执行, 当其他非守护线程都执行结束后, 自动退出
特点：男守护女，女的死，男的也不想活了
join(), 当前线程暂停, 等待指定的线程执行结束后, 当前线程再继续
join(int), 可以等待指定的毫秒之后继续

3.3 加入线程(了解)

3.4 线程让出(了解)

yield() 让出cpu

3.5 线程优先级

setPriority()设置线程的优先级
默认优先级是5，最小优先级1，最高优先级10
可以设置2，3，4
Thread里面有静态常量
开发几乎不用，了解

4 线程与同步

什么是同步

同步就是加锁，不让其它人访问
synchronized指的就是同步的意思
当多线程并发, 有多段代码同时执行时, 我们希望某一段代码执行的过程中CPU不要切换到其他线程工作. 这时就需要同步.
如果两段代码是同步的, 那么同一时间只能执行一段, 在一段代码没执行结束之前, 不会执行另外一段代码.

什么情况下需要同步

同步代码块

使用synchronized关键字加上一个锁对象来定义一段代码, 这就叫同步代码块
多个同步代码块如果使用相同的锁对象, 那么他们就是同步的

同步方法

使用synchronized关键字修饰一个方法, 该方法中所有的代码都是同步的
非静态同步函数的锁是:this
静态同步函数的锁是:字节码对象(xx.class)

案例：卖火车票

需求，有A\B\C\D4个窗口同时买票，只有100张票可买

死锁

回顾线程安全的类

Vector,StringBuffer,Hashtable,Collections.synchroinzed(xxx)
Vector是线程安全的,ArrayList是线程不安全的
StringBuffer是线程安全的,StringBuilder是线程不安全的
Hashtable是线程安全的,HashMap是线程不安全的

线程

1 线程概述

1.1 什么是线程

v 线程是程序执行的一条路径, 一个进程中可以包含多条线程

v 一个应用程序可以理解成就是一个进程

v 多线程并发执行可以提高程序的效率, 可以同时完成多项工作

1.2 多线程应用场景

VNC同时共享屏幕给多个电脑
迅雷开启多条线程一起下载
QQ同时和多个人一起视频
服务器同时处理多个客户端请求

1.3并行和并发的区别

并行就是两个任务同时运行，就是甲任务进行的同时，乙任务也在进行。(需要多核CPU)
并发是指两个任务都请求运行，而处理器只能按受一个任务，就把这两个任务安排轮流进行，由于间时间隔较短，使人感觉两个任务都在运行（画图-任务调度）。

1.4 Java程序运行原理

Java命令会启动java虚拟机(JVM)，等于启动了一个应用程序，也就是启动了一个进程。
该进程会自动启动一个 “主线程” ，然后主线程去调用某个类的 main 方法
一个应用程序有且只有一个主线程,程序员不能New主线程，可以New子线程。

1.5 JVM启动的是多线程吗？

JVM启动至少启动了垃圾回收线程和主线程，所以是多线程的。
main方法的代码执行的位置就是在主线程(路径)
一个进程有多个线程
finalize()这个方法在子线程(垃圾回收线程)执行

public class Demo01 {

public static void main(String[] args) {

/*JVM的启动是多线程的吗？【面试题】*/

System.out.println("AAAAA");

System.out.println("BBBBB");

System.out.println("CCCCC");

System.out.println("DDDDD");

//打印线程名称

System.out.println(Thread.currentThread());//主线程

for(int i = 0;i<2;i++){

new Student();

System.gc();//启动垃圾回收

}

class Student{

//被垃圾回收器回收时，会调用

//对象从内存释放时，会调用

@Override

protected void finalize() throws Throwable {

// TODO Auto-generated method stub

System.out.println("student 被回收了...");

//打印线程名称

System.out.println(Thread.currentThread());//子线程

}

2 Java中线程的实现方式

2.1方式一、继承Thread

使用步骤：

1．定义类继承Thread

2．重写run方法

3．把新线程要做的事写在run方法中

4．创建线程对象

5．开启新线程, 内部会自动执行run方法

代码：

public class Demo01 {

public static void main(String[] args) {

/*主线程，程序员不能创建，程序员只能创建子线程*/

//1.创建子线程对象

MyThread t1 = new MyThread();

/**不能通过下面的方式来执行任务

* 因为这种试的任务是在主线程执行的*/

//t1.run();

//2.正确的执行任务的方式,调用start,内部会开启新线程，调用run方法

t1.start();

//3.再创建子线程

MyThread t2 = new MyThread();

t2.start();

//4.循环创建子线程

for(int i=0;i<10;i++){

MyThread th = new MyThread();

th.start();

}

class MyThread extends Thread{

@Override

public void run() {

System.out.println("银行信用卡还款短信任务..." + Thread.currentThread());

System.out.println("线程名称" + this.getName());

}

2.2方式二、实现Runnable接口

实现步骤：

1.定义类实现Runnable接口

2.实现run方法

3.把新线程要做的事写在run方法中

4.创建自定义的Runnable的子类对象,创建Thread对象传入Runnable

5.调用start()开启新线程, 内部会自动调用Runnable的run()方法

代码：

public class Demo01 {

public static void main(String[] args) {

/* 线程实现的方式 (2) - 定义类实现Runnable接口

//1.创建runable对象

BankTask task = new BankTask();

//2.创建Thread对象

Thread t1 = new Thread(task);

//3.启动线程

t1.start();

//4.再开启2个线程

Thread t2 = new Thread(task);

t2.start();

Thread t3 = new Thread(task);

t3.start();

}

class BankTask implements Runnable{

@Override

public void run() {

// TODO Auto-generated method stub

System.out.println("银行储蓄卡自动结算利息任务..." + Thread.currentThread());

//System.out.println("线程名称:" + this.getName());

System.out.println("线程名称:" +Thread.currentThread().getName());

}

2.3两种方式的区别

区别:

继承Thread : 由于子类重写了Thread类的run(), 当调用start()时直接找子类的run()方法
实现Runnable : 构造函数中传入了Runnable的引用, 有个成员变量记住了它, 调用run()方法时内部判断成员变量Runnable的引用是否为空。

继承Thread

好处是:可以直接使用Thread类中的方法,代码简单
弊端是:如果已经有了父类,就不能用这种方法

实现Runnable接口

好处是:即使自己定义的线程类有了父类也没关系,因为有了父类也可以实现接口,代码更灵活
弊端是:不能直接使用Thread中的方法,需要先获取到线程对象后,才能得到Thread的方法,代码复杂

2.4 匿名内部类实现线程的两种方式

public static void main(String[] args) {

//匿名内部类实现线程的两种方式

/*Thread t1 = new Thread(){

@Override

public void run() {

System.out.println("任务1...." + Thread.currentThread());

}

};

t1.start();*/

new Thread(){

public void run() {

System.out.println("任务1...." + Thread.currentThread());

};

}.start();

/*Thread t2 = new Thread(new Runnable() {

@Override

public void run() {

System.out.println("任务2...." + Thread.currentThread());

}

});

t2.start();*/

new Thread(new Runnable() {

@Override

public void run() {

System.out.println("任务2...." + Thread.currentThread());

}

}).start();

}

2.5 获取线程名字和设置名字

通过Thread的getName()方法获取线程对象的名字
通过setName(String)方法可以设置线程对象的名字
通过构造函数可以传入String类型的名字
每个线程系统都会默认分配个名字,主线程：main,子线程thread-0 ....

public class Demo01 {

public static void main(String[] args) {

/* 获取线程名字和设置名字(掌握)

//1.获取主线程对象

Thread mainThread = Thread.currentThread();

System.out.println(Thread.currentThread());

System.out.println(mainThread);

System.out.println("名称:" + mainThread.getName());

//2.设置线程的名称

mainThread.setName("主线程");

System.out.println(mainThread);

//3.设置子线程的名称

MyThread myThread = new MyThread("子线程1");

myThread.start();

}

class MyThread extends Thread{

public MyThread(String name) {

super(name);

}

@Override

public void run() {

System.out.println("银行代发工资任务..." + Thread.currentThread());

}

2.6 获取当前线程的对象

Thread.currentThread()方法用于获取当前线程对象
在不同的方法中，获取的线程对象名称是有可能不一样的
在main中获取的是主线程对象
在子线程的run方法中获取的是子线程对象

public class Demo01 {

public static void main(String[] args) {

//获取当前线程的对象(掌握)

Thread mainThread = Thread.currentThread();

mainThread.setName("主线程");

//打印主线程对象

System.out.println(mainThread);

//打印主线程对象类名

System.out.println(mainThread.getClass());

System.out.println("================");

//开启子线程

MyThread mt = new MyThread();

mt.start();

}

class MyThread extends Thread{

@Override

public void run() {

System.out.println("任务...");

Thread subThread = Thread.currentThread();

//打印子线程对象

System.out.println(subThread);

//打印子线程对象类名

System.out.println(subThread.getClass().getName());

}

3 线程的其它方法

3.1 线程休眠(掌握)

Thread.sleep(毫秒), 控制当前线程休眠若干毫秒
1秒= 1000毫秒
1秒 = 1000毫秒* 1000微妙 * 1000纳秒（1000000000 ）

主线程休眠

/*** 主线程休眠 */

public static void test1() {

for(int i=0;i<10;i++){

System.out.println(i);

//休眠【暂停】

try {

Thread.sleep(1000);//主线程休眠

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

System.out.println("AAAAAAAAAAAAAAAAAA");

}

子线程休眠

/**

* 子线程休眠

public static void test2() {

//子线程休眠

new Thread(){

public void run() {

for(int i=0;i<10;i++){

System.out.println(Thread.currentThread() + " " + i);

//休眠

try {

Thread.sleep(1000);

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

};

}.start();

System.out.println("AAAAAAAAAAAAAAAA");

}

3.2 守护线程(了解)

setDaemon(), 设置一个线程为守护线程, 该线程不会单独执行, 当其他非守护线程都执行结束后, 自动退出
特点：男守护女，女的死，男的也不想活了
join(), 当前线程暂停, 等待指定的线程执行结束后, 当前线程再继续
join(int), 可以等待指定的毫秒之后继续

3.3 加入线程(了解)

3.4 线程让出(了解)

yield() 让出cpu

3.5 线程优先级

setPriority()设置线程的优先级
默认优先级是5，最小优先级1，最高优先级10
可以设置2，3，4
Thread里面有静态常量
开发几乎不用，了解

4 线程与同步

什么是同步

同步就是加锁，不让其它人访问
synchronized指的就是同步的意思
当多线程并发, 我们希望某一段代码执行的过程中CPU不要切换到其他线程工作. 这时就需要同步,否则会有线程安全问题.

什么情况下需要同步

同步代码块

使用synchronized关键字加上一个锁对象来定义一段代码, 这就叫同步代码块
多个同步代码块如果使用相同的锁对象, 那么他们就是同步的
使用同步锁时，应该尽是让锁的范围小点，才能提高性能

同步方法

使用synchronized关键字修饰一个方法, 该方法中所有的代码都是同步的
非静态同步方法的锁是:this
静态同步方法的锁是:字节码对象(xx.class)

案例：卖火车票

需求，有A\B\C\D4个窗口同时买票，只有100张票可买
多线程会有安全问题熟记

//火车站卖票【问题】

/**

* 湖南到广州火车票：今天13：00 ，100张

* 火车站有4个窗口在同时卖票，要保证一张票只能被卖一次

* 搞4个线程表示4个窗口

* 通过加锁可以解决被多次卖同一张票的问题

* 使用同步代码块

//创建卖票的任务

TicketTask task = new TicketTask();

//A窗口

Thread t1 = new Thread(task);

t1.setName("窗口A");

//B窗口

Thread t2 = new Thread(task);

t2.setName("窗口B");

//C窗口

Thread t3 = new Thread(task);

t3.setName("窗口C");

//D窗口

Thread t4 = new Thread(task);

t4.setName("窗口D");

//开启线程

t1.start();

t2.start();

t3.start();

t4.start();

class TicketTask implements Runnable{

//只有100张票

int ticket = 100;

@Override

public synchronized void run() {

//卖票

while (true) {

if (ticket <= 0) {

System.out.println("不好意思，票已经卖完了...");

break;

} else {

System.out.println(Thread.currentThread() + "恭喜你卖到票，票号" + ticket);

ticket--;

}

/*@Override

public void run() {

// TODO Auto-generated method stub

*//**

* 同步代码换括号里参数可以传任意对象

* this是一个锁对象

* 不同的一把锁，卖相同的票总是还是存在

*//*

//卖票

while (true) {

synchronized (String.class) {// 同步：加锁

if (ticket <= 0) {

System.out.println("不好意思，票已经卖完了...");

break;

} else {

System.out.println(Thread.currentThread() + "恭喜你卖到票，票号" + ticket);

ticket--;

}

}*/

/*@Override

public void run() {

// TODO Auto-generated method stub

*//**

* 同步代码换括号里参数可以传任意对象

*//*

synchronized (this) {

//卖票

while(true){

if(ticket <= 0){

System.out.println("不好意思，票已经卖完了...");

break;

}else{

System.out.println(Thread.currentThread() + "恭喜你卖到票，票号" + ticket);

ticket --;

}

}*/

}

锁的总结

/**

* 1.锁问题：

* 同步中，锁最好同一个对象，如果不是同一对象，还是会有线程安全问题

* 锁：this,代表当前对象

* 锁：如果 new 对象，就不是同一把锁

* 锁：字节码对象 String.class,内存中，只有一个字节码对象

* 开发中：一般都是this

* 2.在方法内部声明synchronized的就是 “同步代码块”

* 3.在声明方法的时候，添加 synchronized，就是同步方法

* 》如果是非静态方法，锁就是this

* 》如果是静态方法，锁就当前类的字节码对象

* //TicketTask.class

public static synchronized void test1(){}

* 4.同步使用的建议：

* 同步加锁的时候，尽量让锁住的代码范围小一点，这样可以让其它线程等待时间少一点，性能高

死锁

死锁就是大家都抱着锁，不释放

public class Demo {

static String s1 = "筷子左";

static String s2 = "筷子右";

public static void main(String[] args) {

new Thread(){

public void run() {

while(true){

synchronized (s1) {

System.out.println("线程A 拿到" + s1 + " 等待" + s2);

synchronized (s2) {

System.out.println("线程A 拿到" + s2 + " 开吃");

}

};

}.start();

new Thread(){

public void run() {

while(true){

synchronized (s2) {

System.out.println("线程B 拿到" + s2 + " 等待" + s1);

synchronized (s1) {

System.out.println("线程B 拿到" + s1 + " 开吃");

}

};

}.start();

}

回顾线程安全的类

Vector,StringBuffer,Hashtable
Vector是线程安全的,ArrayList是线程不安全的
StringBuffer是线程安全的,StringBuilder是线程不安全的
Hashtable是线程安全的,HashMap是线程不安全的

5单例设计模式

5.1什么是单例

保证类在内存中只有一个对象。
对象是new出来的,因此也就是说在程序中只能new一次对象

5.2 单例实现的基本步骤

1》声明一个类，类中有一个静态属性，类型与类名相同

2》把空参构造方法声明为私有

3》在类中提供一个公共静态访问方法来返回该对象实例

5.3 单例的多种写法

写法一饿汉式

class Singleton{

private static Singleton instance = new Singleton();

private Singleton(){}

public static Singleton getInstance(){

return instance;

}

写法二懒汉式

class Singleton{

private static Singleton instance;

private Singleton(){}

public static Singleton getInstance(){

if(instance == null){

instance = new Singleton();

}

return instance;

}

写法三另一种简单

class Singleton{

public static final Singleton instance = new Singleton();

private Singleton(){}

}

5.4饿汉式和懒汉式的区别

饿汉式是空间换时间,懒汉式是时间换空间
在多线程访问时,饿汉式不会创建多个对象,而懒汉式有可能会创建多个对象
如果考虑线程安全问题，用饿汉式
如果不考虑线程安全问题，用懒汉式

5.5 Runtime类的使用

Runtime类是一个单例类
每个 Java 应用程序都有一个 Runtime 类实例，使应用程序能够与其运行的环境相连接。通过 getRuntime 方法获取当前运行时。
案例:自动关机

Runtime r = Runtime.getRuntime();

r.exec("shutdown -s -t 300");//300秒后关机

r.exec("shutdown -a"); //取消关机

6 Timer定时器

Timer一种工具，用于在后台线程中执行的任务。可安排任务执行一次，或者定期重复执行。
方法

public void schedule(TimerTask task, long delay)

public void schedule(TimerTask task, long delay, long period)

public void schedule(TimerTask task, Date firstTime, long period)

public static void test3() {

/**定时器的细节

* 1.定时器在子线程中执行

* 2.timer.cancel(); 取消定时器

Timer timer = new Timer();

timer.schedule(new TimerTask() {

int count = 5;

@Override

public void run() {

// TODO Auto-generated method stub

System.out.println("任务A：" + count +"..." + Thread.currentThread());

count --;

if(count == 0){

//取消定时器

timer.cancel();

}

}, 1000,2000);

//timer.cancel();//主线程

}

7 线程间的通讯

7.1 什么时候需要通信

多个线程并发执行时, 在默认情况下CPU是随机切换线程的，如果我们希望他们有规律的执行, 就可以使用通信, 例如每个线程执行一次打印

7.2 线程怎么通信

》如果希望线程等待, 就调用wait()

》如果希望唤醒等待的线程, 就调用notify();

notify是随机唤醒一个线程

notifyAll是唤醒所有线程

》这两个方法必须在同步代码中执行, 并且使用同步锁对象来调用

》如果方法中没有同步锁，会有异常IllegalMonitorStateException

7.3 案例：两个线程间的通讯

public class Demo01 {

public static void main(String[] args) {

//1.创建任务对象

MyTask task = new MyTask();

//2.开启两个线程执行2个任务

new Thread(){

public void run() {

while(true){

try {

task.task1();

} catch (InterruptedException e1) {

// TODO Auto-generated catch block

e1.printStackTrace();

}

try {

Thread.sleep(10);

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

};

}.start();

new Thread(){

public void run() {

while(true){

try {

task.task2();

} catch (InterruptedException e1) {

// TODO Auto-generated catch block

e1.printStackTrace();

}

try {

Thread.sleep(10);

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

};

}.start();

}

class MyTask{

//标识 1:可以执行任务1，2:可以执行任务2

int flag = 1;

public synchronized void task1() throws InterruptedException{

if(flag != 1){

this.wait();//当前线程等待

}

System.out.println("1.银行信用卡自动还款任务...");

flag = 2;

this.notify();//唤醒其它线程

}

public synchronized void task2() throws InterruptedException{

if(flag != 2){

this.wait();//线程等待

}

System.out.println("2.银行储蓄卡自动结算利息任务...");

flag = 1;

this.notify();//唤醒其它线程

}

7.4 案例：三个线程间的通讯

public class Demo01 {

public static void main(String[] args) {

//三个线程间的通讯

MyTask task = new MyTask();

new Thread(){

public void run() {

while(true){

try {

task.task1();

} catch (InterruptedException e1) {

// TODO Auto-generated catch block

e1.printStackTrace();

}

try {

Thread.sleep(10);

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

};

}.start();

new Thread(){

public void run() {

while(true){

try {

task.task2();

} catch (InterruptedException e1) {

// TODO Auto-generated catch block

e1.printStackTrace();

}

try {

Thread.sleep(10);

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

};

}.start();

new Thread(){

public void run() {

while(true){

try {

task.task3();

} catch (InterruptedException e1) {

// TODO Auto-generated catch block

e1.printStackTrace();

}

try {

Thread.sleep(10);

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

};

}.start();

}

class MyTask{

//标识 1:可以执行任务1，2:可以执行任务2, 3:可以执行任务3

int flag = 1;

public synchronized void task1() throws InterruptedException{

if(flag != 1){

this.wait();//当前线程等待

//this.wait(timeout);

}

System.out.println("1.银行信用卡自动还款任务...");

flag = 2;

//this.notify();//唤醒随机线程

this.notifyAll();//唤醒所有等待线程

}

public synchronized void task2() throws InterruptedException{

if(flag != 2){

this.wait();//线程等待

}

System.out.println("2.银行储蓄卡自动结算利息任务...");

flag = 3;

//this.notify();//唤醒其它线程

this.notifyAll();

//Thread.sleep(millis);

}

public synchronized void task3() throws InterruptedException{

if(flag != 3){

this.wait();//线程等待

}

System.out.println("3.银行短信提醒任务...");

flag = 1;

//this.notify();//唤醒其它线程

this.notifyAll();

}

7.5 线程通讯的一些疑问

1.在同步代码块中,用哪个对象锁,就用哪个对象调用wait方法

2.为什么wait方法和notify方法定义在Object这类中?

因为锁对象可以是任意对象,Object是所有的类的基类,所以wait方法和notify方法需要定义在Object这个类中

3.sleep方法和wait方法的区别?

》sleep方法必须传入参数,参数就是时间,时间到了自动醒来

》wait方法可以传入参数也可以不传入参数,传入参数就是在参数的时间结束后等待,不传入参数就是直接等待

》sleep方法在同步函数或同步代码块中,不释放锁,睡着了也抱着锁睡

》wait方法在同步函数或者同步代码块中,释放锁

7.6 JDK1.5新特性互斥锁

ReentrantLock介绍

使用ReentrantLock类也可以实现同步加锁
ReentrantLock叫[互斥锁]，使用lock()和unlock()方法进行同步
使用ReentrantLock类的newCondition()方法可以获取Condition对象
需要等待的时候使用Condition的await()方法, 唤醒的时候用signal()方法
不同的线程使用不同的Condition, 这样就能区分唤醒的时候找哪个线程了

使用ReentrantLock类使用要点

案例：

/**

* 互斥锁的使用步骤

* 1.创建互斥锁对象

* 2.创建3个Condition

* 3.加锁、解锁

* 4.线程等待-Condition的await方法

* 5.线程唤醒-Condition的signal方法

* @author gyf

class MyTask{

//创建互斥锁对象

ReentrantLock rl = new ReentrantLock();

//创建3个Condition

Condition c1 = rl.newCondition();

Condition c2 = rl.newCondition();

Condition c3 = rl.newCondition();

//标识 1:可以执行任务1，2:可以执行任务2, 3:可以执行任务3

int flag = 1;

public void task1() throws InterruptedException{

rl.lock();//加锁

if(flag != 1){

c1.await();//当前线程等待

}

System.out.println("1.银行信用卡自动还款任务...");

flag = 2;

//指定唤醒线程2

c2.signal();

rl.unlock();//解锁

}

public void task2() throws InterruptedException{

rl.lock();

if(flag != 2){

c2.await();//线程等待

}

System.out.println("2.银行储蓄卡自动结算利息任务...");

flag = 3;

//唤醒线程3

c3.signal();

rl.unlock();

}

public void task3() throws InterruptedException{

rl.lock();

if(flag != 3){

c3.await();//线程等待

}

System.out.println("3.银行短信提醒任务...");

flag = 1;

//唤醒线程1

c1.signal();

rl.unlock();

}

8 线程组

8.1 概述

1.Java中使用ThreadGroup来表示线程组，它可以对一批线程进行分类管理，Java允许程序直接对线程组进行控制。

2.默认情况下，所有的线程都属于主线程组。

3.public final ThreadGroup getThreadGroup() 通过线程对象获取他所属于的组

4.public final String getName() 通过线程组对象获取组的名字

5.我们也可以给线程设置分组ThreadGroup(String name) 创建线程组对象并给其赋值名字

8.2 创建线程对象

Thread(ThreadGroup?group, Runnable?target, String?name)

8.3 代码演示

/**

* 掌握：

* 1.如何获取一个线程所属的线程组

* 2.如果在创建一个子线程时，设置它所属的线程组

* @author gyf

public class Demo01 {

public static void main(String[] args) {

//主线程

Thread mainThread = Thread.currentThread();

/**

* [main,5,main]

* main:线程名称

* 5：代先级

* main:当前线程所属的组名

System.out.println("线程：" + mainThread);

//获取线程的“线程组”对象

ThreadGroup tg = mainThread.getThreadGroup();

System.out.println("线程组：" + tg.getName());

//创建子线程

Thread t1 = new Thread(){

@Override

public void run() {

System.out.println("线程A...");

}

};

//t1.start();

System.out.println("t1子线程的线程组:" + t1.getThreadGroup());

//创建一个线程组

ThreadGroup abcGroup = new ThreadGroup("abc组");

//创建子线程对象

Thread t2 = new Thread(abcGroup, new Runnable() {

@Override

public void run() {

// TODO Auto-generated method stub

System.out.println("线程B");

}

});

System.out.println("t2子线程的线程组：" + t2.getThreadGroup());

}

9 线程池

线程池概述

程序启动一个新线程成本是比较高的，因为它涉及到要与操作系统进行交互。而使用线程池可以很好的提高性能，尤其是当程序中要创建大量生存期很短的线程时，更应该考虑使用线程池。线程池里的每一个线程代码结束后，并不会死亡，而是再次回到线程池中成为空闲状态，等待下一个对象来使用。在JDK5之前，我们必须手动实现自己的线程池，从JDK5开始，Java内置支持线程池

Java的内置线程池

1.JDK5新增了一个Executors工厂类来产生线程池，有如下几个方法

public static ExecutorService newFixedThreadPool(int nThreads)

public static ExecutorService newSingleThreadExecutor()

2. 这些方法的返回值是ExecutorService对象，该对象表示一个线程池，

可以执行Runnable对象或者Callable对象代表的线程。

它提供了如下方法

Future<?> submit(Runnable task)

<T> Future<T> submit(Callable<T> task)

3.使用步骤：

1.创建线程池对象

2.创建Runnable实例

3.提交Runnable实例

4.关闭线程池es.shutdown();

4.Runnable和Callable的区别

Runnable的run方法没有返回值

Callable的call方法有返回值，一般返回值也没用

案例演示

public class Demo01 {

public static void main(String[] args) {

//案例：10个线程完成10个洗车任务

/*for(int i = 0;i<10;i++){

new Thread(){

public void run() {

System.out.println("洗车任务 " + Thread.currentThread());

};

}.start();

}*/

//案例:5个线程完成10个洗车的任务

//1.创建线程池

ExecutorService es = Executors.newFixedThreadPool(5);

//2.添加任务-方式一

/*for(int i=0;i<10;i++){

es.submit(new Runnable() {

@Override

public void run() {

System.out.println("洗车任务 " + Thread.currentThread());

}

});

}*/

//3.添加任务-方式二

for(int i=0;i<10;i++){

es.submit(new MyTask());

}

class MyTask implements Callable<Integer>{

@Override

public Integer call() throws Exception {

System.out.println("洗车任务 " + Thread.currentThread());

return 110;

}

10 线程的五种状态

新建,就绪,运行,阻塞,死亡

posted @ 2020-03-27 09:41 2eggs Views(467) Comments(0) Edit 收藏举报

刷新页面返回顶部

2eggs 双皇蛋

多学学，什么鸟都能下个双皇蛋

多线程 java 同步 、锁 、 synchronized 、 Thread 、 Runnable

1 线程概述

1.1 什么是线程

1.2 多线程应用场景

1.3并行和并发的区别

1.4 Java程序运行原理

1.5 JVM启动的是多线程吗？

2 Java中线程的实现方式

2.1方式一、继承Thread

2.2方式二、实现Runnable接口

2.3两种方式的区别

2.4 匿名内部类实现线程的两种方式

2.5 获取线程名字和设置名字

2.6 获取当前线程的对象

3 线程的其它方法

3.1 线程休眠(掌握)

3.2 守护线程(了解)

3.3 加入线程(了解)

3.4 线程让出(了解)

3.5 线程优先级

4 线程与同步

什么是同步

什么情况下需要同步

同步代码块

同步方法

案例：卖火车票

死锁

回顾线程安全的类

1 线程概述

1.1 什么是线程

1.2 多线程应用场景

1.3并行和并发的区别

1.4 Java程序运行原理

1.5 JVM启动的是多线程吗？

2 Java中线程的实现方式

2.1方式一、继承Thread

2.2方式二、实现Runnable接口

2.3两种方式的区别

2.4 匿名内部类实现线程的两种方式

2.5 获取线程名字和设置名字

2.6 获取当前线程的对象

3 线程的其它方法

3.1 线程休眠(掌握)

3.2 守护线程(了解)

3.3 加入线程(了解)

3.4 线程让出(了解)

3.5 线程优先级

4 线程与同步

什么是同步

什么情况下需要同步

同步代码块

同步方法

案例：卖火车票

锁的总结

死锁

回顾线程安全的类

5单例设计模式

5.1什么是单例

5.2 单例实现的基本步骤

5.3 单例的多种写法

5.4饿汉式和懒汉式的区别

5.5 Runtime类的使用

6 Timer定时器

7 线程间的通讯

7.1 什么时候需要通信

7.2 线程怎么通信

7.3 案例：两个线程间的通讯

7.4 案例：三个线程间的通讯

7.5 线程通讯的一些疑问

7.6 JDK1.5新特性互斥锁

ReentrantLock介绍

使用ReentrantLock类使用要点

案例：

8 线程组

8.1 概述

8.2 创建线程对象

8.3 代码演示

9 线程池

多线程 java 同步、锁、 synchronized 、 Thread 、 Runnable