多线程并行和并发的区别
开启线程的方法（一）
1.5 创建线程方式一继承Thread类
创建线程的步骤：
1 定义一个类继承Thread。
2 重写run方法。
3 创建子类对象，就是创建线程对象。
4 调用start方法，开启线程并让线程执行，同时还会告诉jvm去调用run方法。
l 测试类
public class Demo01 {
public static void main(String[] args) {
//创建自定义线程对象
MyThread mt = new MyThread("新的线程！");
//开启新线程
mt.start();
//在主方法中执行for循环
for (int i = 0; i < 10; i++) {
System.out.println("main线程！"+i);
}
}
}
l 自定义线程类
public class MyThread extends Thread {
//定义指定线程名称的构造方法
public MyThread(String name) {
//调用父类的String参数的构造方法，指定线程的名称
super(name);
}
/**
* 重写run方法，完成该线程执行的逻辑
*/
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println(getName()+"：正在执行！"+i);
}
}
}思考：线程对象调用 run方法和调用start方法区别？
线程对象调用run方法不开启线程。仅是对象调用方法。线程对象调用start开启线程，并让jvm调用run方法在开启的线程中执行。
开启线程的方法（二）
1.6 创建线程方式—实现Runnable接口
创建线程的另一种方法是声明实现 Runnable 接口的类。该类然后实现 run 方法。然后创建Runnable的子类对象，传入到某个线程的构造方法中，开启线程。
为何要实现Runnable接口，Runable是啥玩意呢？继续API搜索。
查看Runnable接口说明文档：Runnable接口用来指定每个线程要执行的任务。包含了一个 run 的无参数抽象方法，需要由接口实现类重写该方法。
l 接口中的方法
l Thread类构造方法
创建线程的步骤。
1、定义类实现Runnable接口。
2、覆盖接口中的run方法。。
3、创建Thread类的对象
4、将Runnable接口的子类对象作为参数传递给Thread类的构造函数。
5、调用Thread类的start方法开启线程。
l 代码演示：
public class Demo02 {
public static void main(String[] args) {
//创建线程执行目标类对象
Runnable runn = new MyRunnable();
//将Runnable接口的子类对象作为参数传递给Thread类的构造函数
Thread thread = new Thread(runn);
Thread thread2 = new Thread(runn);
//开启线程
thread.start();
thread2.start();
for (int i = 0; i < 10; i++) {
System.out.println("main线程：正在执行！"+i);
}
}
}
l 自定义线程执行任务类
public class MyRunnable implements Runnable{
//定义线程要执行的run方法逻辑
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println("我的线程：正在执行！"+i);
}
}
}1.6.1 实现Runnable的原理
为什么需要定一个类去实现Runnable接口呢？继承Thread类和实现Runnable接口有啥区别呢？
实现Runnable接口，避免了继承Thread类的单继承局限性。覆盖Runnable接口中的run方法，将线程任务代码定义到run方法中。
创建Thread类的对象，只有创建Thread类的对象才可以创建线程。线程任务已被封装到Runnable接口的run方法中，而这个run方法所属于Runnable接口的子类对象，所以将这个子类对象作为参数传递给Thread的构造函数，这样，线程对象创建时就可以明确要运行的线程的任务。
1.6.2 实现Runnable的好处
第二种方式实现Runnable接口避免了单继承的局限性，所以较为常用。实现Runnable接口的方式，更加的符合面向对象，线程分为两部分，一部分线程对象，一部分线程任务。继承Thread类，线程对象和线程任务耦合在一起。一旦创建Thread类的子类对象，既是线程对象，有又有线程任务。实现runnable接口，将线程任务单独分离出来封装成对象，类型就是Runnable接口类型。Runnable接口对线程对象和线程任务进行解耦。
两种方式的区别
总结
3.1 知识点总结
l 创建线程的方式
l 方式1，继承Thread线程类
l 步骤
1， 自定义类继承Thread类
2， 在自定义类中重写Thread类的run方法
3， 创建自定义类对象(线程对象)
4， 调用start方法，启动线程，通过JVM，调用线程中的run方法
l 方式2，实现Runnable接口
l 步骤
1， 创建线程任务类 实现Runnable接口
2， 在线程任务类中 重写接口中的run方法
3， 创建线程任务类对象
4， 创建线程对象，把线程任务类对象作为Thread类构造方法的参数使用
5， 调用start方法，启动线程，通过JVM，调用线程任务类中的run方法
匿名内部类实现线程的两种方式
package com.xiancheng;
public class runnable {
public static void main(String[] args) {
new Thread() { //1.继承Thread类
public void run() { //2.重写run方法
for (int i = 0; i < 1000; i++) {//3.将要执行的代码写在run方法中
System.out.println("aaaa");
}
}
}.start();
//第二种方法
new Thread(new Runnable() { //1、将Runnable的子类对象传递給Thread的构造方法
@Override
public void run() { //2.重写run方法
for (int i = 0; i <1000; i++) { //3.将要执行的代码写在run方法中
System.out.println("bbbb");
}
}
}).start(); //4.开启线程
}
}获取当前线程对象
package com.xiancheng;
public class Demo_CurrentThread {
//currentThread()
返回对当前正在执行的线程对象的引用
public static void main(String[] args) {
new Thread() { //1.继承Thread类
public void run() { //2.重写run方法
for (int i = 0; i < 1000; i++) {//3.将要执行的代码写在run方法中
System.out.println(this.getName() + "aaaa");
}
}
}.start();
new Thread(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + "aaa");
}
}).start();
System.out.println(Thread.currentThread().getName());
}
}守护线程
package com.xiancheng;
public class Demo_Damon {
/*
* 守护线程
*/
public static void main(String[] args) {
Thread t1 = new Thread() {
public void run() {
for (int i = 0; i <2; i++) {
System.out.println(getName() + "aaa");
}
}
};
Thread t2 = new Thread() {
public void run() {
for (int i = 0; i <50; i++) {
System.out.println(getName() + "bbbbb");
}
}
};
t2.setDaemon(true); 将t1设置为守护线程
t1.start();
t2.start();
}
}加入线程
package com.xiancheng;
public class Demo_join {
public static void main(String[] args) {
final Thread t1 = new Thread() {
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println(getName() + "aaa");
}
}
};
Thread t2 = new Thread() {
public void run() {
for (int i = 0; i < 10; i++) {
if(i == 2) {
try {
t1.join();
}catch(InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(getName() + "..bbb");
}
}
};
t1.start();
t2.start();
}
}多线程（同步代码块）
class Printer {
Demo d = new Demo();
public void print1() {
synchronized(d) { //同步代码块，锁机制，锁对象可以是任意机制
System.out.println("1");
System.out.println("2");
System.out.println("3");
System.out.println("4");
System.out.println("\r\n");
}
}线程安全问题
package com.xiancheng;
public class Demo_Ticket {
public static void main(String[] args) {
new Ticket().start();
new Ticket().start();
new Ticket().start();
new Ticket().start();
}
}
class Ticket extends Thread {
private static int ticket = 100;
public void run() {
while(true) {
synchronized(Ticket.class) { //锁对象。就不会出现问题
if(ticket == 0) {
break;
}
try {
Thread.sleep(10);
}catch(InterruptedException e) {
e.printStackTrace();
}
System.out.println(getName() + "...这是第"+ ticket-- + "号票");
}
}
}
}死锁
所谓死锁，是指多个进程在运行过程中因争夺资源而造成的一种僵局，当进程处于这种僵持状态时，若无外力作用，它们都将无法再向前推进。 因此我们举个例子来描述，如果此时有一个线程A，按照先锁a再获得锁b的的顺序获得锁，而在此同时又有另外一个线程B，按照先锁b再锁a的顺序获得锁。如下图所示：
