Java多线程笔记
什么是线程？
线程是程序执行的一条路径，一个进程中可以包含多条线程。一个应用程序可以理解为一个进程。多线程并发执行可以提高程序的效率，可以同时完成多项任务。
多线程并行和并发的区别
- 并行
并行就是两个任务同时运行，就是甲任务进行的同时，乙任务也在进行。（需要多核CPU） - 并发
并发是指两个任务都请求运行，而处理器只能接受一个任务，就把这两个任务安排轮流进行，由于CPU运算速度较快，使人感觉两个任务都在运行。
注意：以上说的两个任务只是举例，可以是多个任务。
Java程序运行原理和JVM启动是多线程的吗？
Java程序运行原理：Java命令会启动Java虚拟机（JVM），等于启动了一个应用程序，也就是启动了一个进程。该进程会自动启动一个“主线程”，然后主线程去调用某个类的main方法。一个应用程序只有一个主线程。
-
JVM是多线程的吗？
JVM启动至少启动了垃圾回收线程和主线程，所以是多线程的。以下代码用来证明JVM是多线成的。
package demo01;public class Demo01 { public static void main(String[] args) { System.out.println("AAA"); System.out.println("BBB"); //打印当前线程名称 System.out.println("当前线程为："+Thread.currentThread().getName()); //模拟java的垃圾回收 for(int i=0; i<2; i++) { new Student(); System.gc(); } } } class Student{ @Override protected void finalize() throws Throwable { //打印当前线程名称 System.out.println("当前线程名称："+Thread.currentThread().getName()); } }
线程的实现方式
-
继承Thread类
使用步骤：定义类继承Thread；重写run方法，把新线程要做的事情写在run方法中；创建线程对象；启动线程。
以下是式例代码：
package demo01;public class Demo02 { public static void main(String[] args) { /** * 本例用来创建多个线程 */ //创建线程对象 MyThread thread = new MyThread(); //启动线程,注意：是调用start方法而run方法，如果直接调用run方法，其实就是在主线程中运行run方法，并没有开启线程。 thread.start(); //循环创建多个线程，用来证明线程的执行，是抢占资源来执行的，并非是有序的。 for(int i=0; i<10; i++) { thread = new MyThread(); thread.start(); } } } class MyThread extends Thread{ @Override public void run() { System.out.println("执行线程任务----"+Thread.currentThread().getName()); } } -
实现Runnable接口
使用步骤：实现Runnable接口；实现run方法，把新线程要做的事情写在run方法中；创建自定义的实现了Runnable的子类对象；创建Thread对象，将自定义的实现Runnable的子类对象传入Thread的构造方法；启动线程。
以下是式例代码：
package demo01;public class Demo03 { public static void main(String[] args) { //使用线程步骤： //创建myTask对象 MyTask task = new MyTask(); //使用Thread的构造方法创建Thread对象 Thread thread = new Thread(task); //启动线程 thread.start(); //循环开启多个线程 for(int i=0; i<10; i++) { thread = new Thread(task); thread.start(); } } } class MyTask implements Runnable{ @Override public void run() { //需要在线程中执行的任务 System.out.println("所要执行的任务----"+Thread.currentThread().getName()); } }
两种方式的区别：
- 继承Thread
好处：可以直接是以哦那个Thread类中的方法，代码简单。
弊端：如果有了父类，就不能用这种方法，因为Java不支持多继承。 - 实现Runnable接口
好处：即使自己定义的线程类有了父类也没有关系，因为有了父类也能实现接口，代码更灵活。
弊端：不能直接使用Thread类中的方法，需要先获取到线程对象后，才能得到Thread的方法，代码复杂。
使用匿名内部类实现多线程，以下是式例代码
package demo01;
public class Demo04 {
public static void main(String[] args) {
//使用匿名内部类实现线程
Thread t1 = new Thread() {
@Override
public void run() {
System.out.println("执行线程任务---------"+this.getName());
}
};
t1.start();
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
System.out.println("执行线程任务---------"+Thread.currentThread().getName());
}
});
t2.start();
}
}
获取线程名称和设置名字
获取名字：通过getName()方法获取线程的名称。
设置名字：1、通过构造方法，可以传入String类型的名字；2、通过SetName(String str)方法设置名字。
注意：每个线程都有一个默认的名字。
获取当前线程对象
式例代码如下：
package demo01;
public class Demo05 {
public static void main(String[] args) {
System.out.println("当前线程的对象"+Thread.currentThread().getClass());
MyThread1 mt = new MyThread1();
mt.start();
}
}
class MyThread1 extends Thread{
@Override
public void run() {
System.out.println("当前线程的对象"+Thread.currentThread().getClass());
}
}
Thread.sleep(m)的使用
式例代码如下：
package demo02;
public class Demo01 {
public static void main(String[] args) {
test1();
System.out.println("会在test1方法执行完后，执行该行代码");
test2();
System.out.println("会在test2方法执行之前执行该代码");
}
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();
}
}
}
static void test2() {
new Thread() {
@Override
public void run() {
for(int i=0; i<10; i++) {
System.out.println("子线程打印："+i);
try {
this.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}.start();
}
}
一个时间倒计时的式例，代码如下：
package demo02;
public class Demo02 {
public static void main(String[] args) {
//倒计时式例
new Thread(new Runnable() {
int m = 60;//注意，该变量不能提到括号外面，因为局部内部类的变量必须要用final修饰，而final修饰的变量只能赋值一次。
@Override
public void run() {
for(int i=0; i守护线程
作用：当非守护线程执行完毕后，守护线程不管是否执行完毕，都会被停止。
式例代码如下：
package demo02;
public class Demo03 {
public static void main(String[] args) {
//守护线程式例
Thread t1 = new Thread() {
@Override
public void run() {
for(int i=0; i<5; i++) {
System.out.println("线程---女"+i);
try {
Thread.sleep(10);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
};
Thread t2 = new Thread() {
@Override
public void run() {
for(int i=0; i<15; i++) {
System.out.println("线程---男"+i);
try {
Thread.sleep(10);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
};
t1.start();
t2.setDaemon(true);
t2.start();
}
}
线程加入
式例代码如下：
package demo02;
public class Demo04 {
public static void main(String[] args) {
Thread t1 = new Thread() {
@Override
public void run() {
for(int i=0; i<100; i++) {
System.out.println("线程A----"+i);
try {
Thread.sleep(10);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
};
Thread t2 = new Thread() {
@Override
public void run() {
for(int i=0; i<100; i++) {
if(i == 10) {
try {
// t1.join(); //将线程A加入进来，且让线程A执行完后，再继续执行线程B
t1.join(100); //将线程A加入进来，且让线程A执行100毫秒后，再继续执行线程B
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
System.out.println("线程B----"+i);
try {
Thread.sleep(10);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
};
t1.start();
t2.start();
}
}
设置线程优先级
式例代码如下：
package demo02;
public class Demo05 {
public static void main(String[] args) {
Thread t1 = new Thread() {
public void run() {
for(int i=0; i<100; i++) {
System.out.println("线程A----"+i);
try {
Thread.sleep(10);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
};
};
Thread t2 = new Thread() {
public void run() {
for(int i=0; i<100; i++) {
System.out.println("线程B----"+i);
try {
Thread.sleep(10);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
};
};
//设置线程优先级，如果不设置，默认5
t1.setPriority(Thread.MIN_PRIORITY);
t2.setPriority(Thread.MAX_PRIORITY);
t1.start();
t2.start();
}
}
同步锁
火车售票式例代码如下：
package demo02;
public class Demo06 {
public static void main(String[] args) {
//使用同步锁实现卖火车票功能
Ticket ticket = new Ticket();
Thread t1 = new Thread(ticket, "1");
Thread t2 = new Thread(ticket, "2");
Thread t3 = new Thread(ticket, "3");
Thread t4 = new Thread(ticket, "4");
t1.start();
t2.start();
t3.start();
t4.start();
}
}
class Ticket implements Runnable{
int ticket = 1000;
@Override
public void run() {
while(true) {
synchronized (this) {
if(ticket >0) {
System.out.println("您在窗口："+Thread.currentThread().getName()+"购票成功，票号为："+ticket);
ticket --;
try {
Thread.sleep(10);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}else {
System.out.println("您在窗口："+Thread.currentThread().getName()+"购票失败，票已售完！");
break;
}
}
}
}
}
同步方法
式例代码如下：
package demo03;
public class Demo01 {
public static void main(String[] args) {
/**
* 线程锁的注意事项：
* 1.线程的锁对象必须要为同一个对象，否则会出现线程安全问题。
* 2.线程的锁对象，可以使用一个字节码对象，如String.class，能保证锁对象为同一个对象，应为在内存中只有一个字节码对象。
* 3.在使用同步方法时，如果时静态方法，则锁对象为该方法所属类的字节码对象，如果为非静态方法，则锁对象为this。
*/
MyThread myThread = new MyThread();
Thread t1 = new Thread(myThread,"1");
Thread t2 = new Thread(myThread,"2");
Thread t3 = new Thread(myThread,"3");
Thread t4 = new Thread(myThread,"4");
t1.start();
t2.start();
t3.start();
t4.start();
}
}
class MyThread implements Runnable{
private int sum = 100;
//线程同步方法的使用
/**
* 线程加锁原则：在保证业务正确的情况下，加锁的代码越少越好，有利于提高效率。减少其他线程的等待时间。
*/
@Override
public synchronized void run() {
while(true) {
if(sum ==0) {
System.out.println("票已经卖完！");
break;
}else {
System.out.println(Thread.currentThread().getName()+"号窗口出售了“"+sum+"”号车票！");
sum--;
}
}
}
}
死锁
死锁的式例代码如下：
package demo03;
public class Demo02 {
private static String a= "A";
private static String b= "B";
public static void main(String[] args) {
/*
* 死锁：多线程的时候，如果同步代码块嵌套，使用相同的锁，就有可能出现死锁。
* 以下是一个死锁的实例
*/
new Thread() {
public void run() {
while(true) {
synchronized (a) {
System.out.println("线程A拿到了A等待B");
synchronized (b) {
System.out.println("线程A拿到了B,A和B在一起了！");
}
}
}
};
}.start();
new Thread() {
public void run() {
while(true) {
synchronized (b) {
System.out.println("线程B拿到了B等待A");
synchronized (a) {
System.out.println("线程B拿到了A,A和B在一起了！");
}
}
}
};
}.start();
}
}