线程1
与线程相关的概念
线程与进程的区别
线程创建策略
线程组
线程创建策略
并发应用中一般有两种不同的线程创建策略
1直接控制线程的创建和管理
2将线程的管理从应用程序中抽象出来作为执行器，应用程序将任务传递给执行器，由执行器负责执行。
线程2
在线程中实现自己的代码逻辑
有3种方式
从Thread类继承
实现runnable接口
使用方法引用到一个无参数无返回值的方法
将参数传入线程中
使用线程类属性的set方法
使用线程类的构造方法传值
package java20180203_1;
class Thread1 extends Thread {
private int num;
public void setNum(int num) {
this.num = num;
}
@Override
public void run() {
for (int i = 0; i < 100; i++) {
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("thread1:" + i+","+num);
}
}
}
class Thread2 implements Runnable {
private int num;
public Thread2(int num) {
this.num = num;
}
@Override
public void run() {
for (int i = 0; i < 100; i++) {
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("thread2:" + i+","+num);
}
}
}
public class ThreadDemo {
static void print(){
for (int i = 0; i < 100; i++) {
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("thread4:" + i);
}
}
public static void main(String[] args) throws Exception {
/**
* 线程组，将线程加入到线程组
*/
Thread t1 = new Thread();
t1.start();
ThreadGroup tg1 = new ThreadGroup("ThreadGroup");
Thread t2 = new Thread(tg1, "t2");
/**
* 从Thread类继承，这是子线程1
*/
Thread1 th1 = new Thread1();
//使用线程类set属性进行传值
th1.setNum(200);
th1.start();
/**
* 实现runnable接口，这是子线程2
*/
//使用构造方法传值
Runnable r2 = new Thread2(300);
Thread t3 = new Thread(r2);
t3.start();
/**
* 用lambda表达式来实现相同的功能，这是子线程3
*/
new Thread(() -> {
for (int i = 0; i < 100; i++) {
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("thread3:" + i);
}
}).start();
/**
* 方法引用来创建线程
*/
new Thread(ThreadDemo::print).start();
/**
* 这是main线程的循环
* 总共有4个线程，一个是main主线程的循环，其余3个是子线程的循环，有3个start，它们是并行的，可以从结果中看到。
* 分发给不同的处理器来执行
*/
for (int i = 0; i < 100; i++) {
Thread.sleep(500);
System.out.println("main:" + i);
}
}
}
线程3
获取线程的信息
线程优先级
线程串行化
线程休眠
获取线程的信息
currentThread()
getName
优先级
默认优先级是5，子默认与父优先级相同，共10个，从1到10。
串行化
若一个线程运行的过程中要用到另一个线程的结果，则可以进行线程的串行化处理
join()方法
休眠
sleep()方法，暂停时间不精确
线程4
线程的状态
线程中断
线程停止
守护线程
线程的状态
可以使用getState()来获取，有New,Runnable,Blocked,Waiting,ThreadWaiting,Dead这6种状态
线程停止
开发中使线程停止的方式不是使用其stop()，已经不推荐使用了
而是使用标识量来停止线程
package java20180205;
public class InterruptDemo {
public static void main(String[] args) throws Exception {
Thread t1=new Thread(()->{
for (int i = 0; i < 20; i++) {
System.out.println(i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
t1.start();
for (int i = 0; i < 20; i++) {
System.out.println("main:"+i);
Thread.sleep(300);
}
t1.interrupt();
/**
* 一个是false，一个是true
*/
// System.out.println(t1.interrupted());
// System.out.println(t1.isInterrupted());
}
}
package java20180205;
class Thread4 implements Runnable{
private boolean stop=false;
public void setStop(boolean stop) {
this.stop = stop;
}
@Override
public void run() {
for (int i = 0;; i++) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
if (stop) {
break;
}
System.out.println(i);
}
}
}
public class StopDemo {
public static void main(String[] args) throws Exception {
// Thread4 t4=new Thread4();
// new Thread(t4).start();
// Thread.sleep(4000);
// t4.setStop(true);
Thread4 t4=new Thread4();
Thread t5=new Thread(t4);
t5.setDaemon(true);
t5.start();
Thread.sleep(4000);
}
}
线程5
多线程访问共享数据的问题
java内存模型
案例
使用多个线程调用一个账号实例中的取款方法
java内存模型
线程安全术语
线程6
对象监视器
synchronized关键字
volatile变量
对象监视器
临界区，监视器上加锁
synchronized关键字
用于声明临界区
两种方法：
synchronized方法
实例方法：锁加在实例上
静态方法：锁加在类上
synchronized块
线程7 05:29
生产者消费者模型
wait与sleep的区别
生产者消费者模型
线程间通信的另一种方式，是一个非常经典的模型