目录
多线程的引入
什么是线程
- 线程是程序执行的一条路径，一个进程中可以包含多条线程
- 多线程并发执行可以提高程序的执行效率，同时可以完成多项工作
多线程的应用场景
- 红蜘蛛同时共享屏幕给多个电脑
- 迅雷开始多条线程一起下载
- qq同时和多个人一起视频
- 服务器同时处理多个客户端请求
多线程并行和并发的区别
并行就是两个任务同时运行，甲任务进行的同时，乙任务 也在同时进行，需要多核cpu
并发就是两个任务都请求运行，而处理器只能接受一个任务，就把这两个任务安排轮流进行，由于时间间隔较短，使人感觉两个任务都在运行
Java程序运行原理和JVM的启动是多线程的吗
java程序运行原理
java命令会启动java虚拟机，启动JVM，等于启动了一个应用程序，也就是启动了一个进程，该进程会自动启动一个主线程，然后主线程取调用某个类的main方法
JVM的启动是多线程的吗
JVM启动至少启动了垃圾回收程和主线程，所以是多线程的
多线程程序实现的方式
继承Thread
- 定义类继承Thread
- 重写run方法
- 把新线程要做的事写在run方法中
- 创建线程对象
- 开启新线程，内部会自动执行run方法
public class test1 {
public static void main(String[] args) {
MyThread mt = new MyThread();
mt.run();
for(int i = 0;i<1000;i++) {
System.out.println("bbb");
}
}
}
class MyThread extends Thread {
public void run() {
for(int i=0;i<1000;i++) {
System.out.println("aaaaaaaaaaaa");
}
}
}
没有开启线程，应该重写start方法，否则就是都在主线程上运行。
将main方法中的mt.run()改为mt.start()
实现runnable
- 定义类实现Runnable接口
- 实现run方法
- 把新线程要做的事写在run方法中
- 创建自定义的Runnable的子类对象
- 创建Thread对象，传入Runnable
- 调用strat()开启新线程，内部会自动调用Runnable的run方法
public class test2 {
public static void main(String[] args) {
MyRunnable mr = new MyRunnable();
Thread t = new Thread(mr); //将其当作参数传递给Thread的构造函数
t.start();
for(int i = 0;i<1000;i++) {
System.out.println("2222");
}
}
}
class MyRunnable implements Runnable {
public void run() {
for(int i=0 ; i<1000 ; i++) {
System.out.println("1111111111111111111");
}
}
}
实现Runnable的原理
- 看Thread类的构造函数，传递了Runnable接口的引用
- 通过init()方法找到传递的target给成员变量target赋值
- 查看run方法，发现run方法中有判断，如果target不为null就会调用Runnable接口子类对象的run方法
两种方式的区别
查看源码的区别：
继承Thread：由于子类重写了Thread类的run()，当调用start()时，直接找子类的run()方法
实现Runnable：构造函数中传入了Runnable的引用，成员变量记住了它，start()调用run()方法时，内部判断成员变量Runnable的引用是否为空，不为空编译时看的是Runnable的run()，运行时 执行的是子类的run()方法
继承Thread:
好处是：可以直接使用Thread类中的方法，代码简单
弊端是：如果已经有了父类就不能用这种方法
实现Runnable接口
好处是：即使自己定义的线程类有了父类也没有关系，因为有了父类也可以实现接口，而且接口是可以多实现的
弊端是：不能直接使用Thread中的方法需要先获取到线程对象后，才能得到Thread的方法，代码复杂。
匿名内部类实现线程的两种方式
public class test3 {
public static void main(String[] args ) {
new Thread() {
public void run() {
for(int i = 0;i < 3000 ;i++) {
System.out.println("aaaaaaaaaaaa");
}
}
}.start();
for(int i=0;i<10000;i++){
System.out.println("bb");
}
}
}public class test4 {
public static void main(String[] args) {
new Thread(new Runnable() {
public void run() {
for(int i = 0;i<10000;i++){
System.out.println("q");
}
}
}).start();
for(int i=0;i<10000;i++){
System.out.println("bb");
}
}
}
获取名字和设置名字
public class test5 {
public static void main(String[] args) {
new Thread("ddd") {
public void run() {
//this.setName("aaaaaa");
System.out.println(this.getName());
}
}.start();
new Thread() {
public void run() {
System.out.println(this.getName());
}
}.start();
}
}
获取当前线程对象
public class test6 {
public static void main(String[] args) {
new Thread() {
public void run() {
System.out.println(getName()+"aaaaaaaaaaaaa");
}
}.start();
new Thread(new Runnable() {
//Thread.currentThread()获取当前执行线程
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"bb");
}
}).start();
}
}
休眠线程
public class test7 {
public static void main(String[] args) throws InterruptedException {
for(int i = 20;i>=0;i--) {
Thread.sleep(1000); //中断异常
System.out.println("倒计时第"+ i + "秒");
}
}
}
传进去的参数是毫秒
守护线程
该线程不会单独执行，当其他非守护线程都执行结束后，自动退出。
public class test8 {
public static void main(String[] args) {
Thread t1 = new Thread() {
public void run() {
for(int i = 0; i<2;i++) {
System.out.println(getName() + "aaaaaaaaa");
}
}
};
Thread t2 = new Thread() {
public void run() {
for(int i = 0; i<50;i++) {
System.out.println(getName() + "bbb");
}
}
};
t2.setDaemon(true); //当传入true意为设置成守护线程
t1.start();
t2.start();
}
}
偶尔会有时间缓冲，因此t2在t1线程结束之后会有缓冲
加入线程
join()，当前线程暂停，等待指定的线程执行结束后，当前线程再继续
join(int),可以等待指定的毫秒之后继续
public class test8 {
public static void main(String[] args) {
final Thread t1 = new Thread() {
public void run() {
for(int i = 0; i<200;i++) {
System.out.println(getName() + "aaaaaaaaa");
}
}
};
Thread t2 = new Thread() {
public void run() {
for(int i = 0; i<50;i++) {
if(i == 2) {
try {
//t1.join();
t1.join(1);//插队1ms
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(getName() + "bbb");
}
}
};
t1.start();
t2.start();
}
}
礼让线程
public class test9 {
public static void main(String[] args) {
new Mytread().start();
new Mytread().start();
}
}
class Mytread extends Thread {
public void run() {
for(int i = 1;i<=1000;i++){
if(i%10==0) {
Thread.yield(); //让出cpu
}
System.out.println(getName()+"...."+i);
}
}
}
设置线程的优先级
public class test10 {
public static void main(String[] args) {
Thread t1 = new Thread() {
public void run() {
for(int i =0 ;i <=1000;i++) {
System.out.println(getName()+"aaaaaaa");
}
}
};
Thread t2= new Thread() {
public void run() {
for(int i =0 ;i <=1000;i++) {
System.out.println(getName()+"b");
}
}
};
// t1.setPriority(10);
// t2.setPriority(1);
t1.setPriority(Thread.MIN_PRIORITY); //设置最小的线程优先级
t2.setPriority(Thread.MAX_PRIORITY); //设置最大的线程优先级
t1.start();
t2.start();
}
}
同步代码块
什么情况下需要同步：
当多线程并发，有多段代码同时执行时，我们希望某一段代码执行过程中cpu不要切换到其他线程工作，这时就需要同步
如果两段代码是同步的，那么同一时间段只能执行一段，在一段代码没执行结束之前，不会执行另一端代码
同步代码块：
使用synchronized关键字加上一个锁对象来定义一段代码，这就叫同步代码快
多个同步代码块如果使用相同的锁对象，那么他们就是同步的
锁对象不能用匿名对象，因为匿名对象不是一个
同步方法
使用synchronized关键字修饰一个方法，该方法中所有的代码都是同步的
非静态同步函数的锁是：this
静态同步函数的锁是字节码对象
线程安全问题
多线程开发操作统一数据就有可能出现线程安全问题
使用同步技术可以解决这种问题，把操作数据的代码同步，不需要多个线程一起操作
死锁
多线程同步的时候如果同步代码嵌套，使用相同锁，就可能出现死锁
学过的类
vector是线程安全的，ArrayList是线程不安全的
StringBuffer是线程安全的，StringBuild是线程不安全的
HashTable是线程安全的 HashMap是线程不安全的
synchronized(XXX)可以将线程不安全的转为线程安全的
4157
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
