Java学习笔记 -多线程1
概述
内存
-
进程之间的内存独立不共享
-
Java中两个线程：
1)共享堆内存和方法区
2)栈内存各自独立 -两个栈
多线程并发下，数据修改会存在线程安全问题，如何解决？
-
线程排队执行，用排队执行解决
-
这种机制称为：线程同步机制
-
异步编程模型：多线程并发
-
同步编程模型：线程排队执行
创建新线程的三种方法
编写自定义线程类
public class ThreadTest01{
public static void main(String[] args) {
MyThread myThread = new MyThread();
//start()方法的作用：开辟一个新的栈空间，开辟完就结束了
//有了新的栈空间就代表线程启动成功，此时run()方法和main()方法具有了相同的地位
//如果只调用run()方法，而没有先分配栈空间，则没有新的线程，run()会使用主线程的栈
myThread.start();
for (int i = 0; i < 1000; i++) {
System.out.println("主线程运行: " + i);
}
}
}
//继承Thread类，重写run()方法
class MyThread extends Thread{
@Override
public void run() {
for (int i = 0; i < 1000; i++) {
System.out.println("分支线程运行: " + i);
}
}
}
直接实现Runnable接口
public class ThreadTest02 {
public static void main(String[] args) {
//面向接口编程(推荐)
Thread t1 = new Thread(new MyRunnable());
//匿名内部类的实现方式
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 1000; i++) {
System.out.println("分支线程运行t2: " + i);
}
}
});
t1.start();
t2.start();
for (int i = 0; i < 1000; i++) {
System.out.println("主线程运行: " + i);
}
}
}
//直接实现Runnable接口，重写run()方法
class MyRunnable implements Runnable{
@Override
public void run() {
for (int i = 0; i < 1000; i++) {
System.out.println("分支线程运行t1: " + i);
}
}
}
实现Callable接口
相比之前的两种方式，这个实现方式有明显的不同：
- 优点：可以获取到线程的执行结果
- 缺点：当前线程受阻，需要等待t线程执行完毕返回结果，效率较低
public class FutureThreadTest {
public static void main(String[] args) throws ExecutionException, InterruptedException {
//1.创建一个“未来任务类对象”，需要传递一个Callable接口的实现对象
FutureTask task =new FutureTask(new Callable() {
@Override
public Object call() throws Exception {
System.out.println(Thread.currentThread().getName() + "执行");
Thread.sleep(1000 * 5);
System.out.println(Thread.currentThread().getName() + "结束");
return 1; //自动装箱
}
});
//2.创建线程对象
Thread t1 = new Thread(task);
t1.setName("t1");
t1.start();
//3.在主线程中如何获取t1线程的执行结果？
//使用task.get()方法
task.get();
//因为要切换到另一个线程执行，当前线程需要阻塞,等待另一个线程执行完毕后，返回执行结果
System.out.println("主线程执行");
}
}
线程常用方法
- void setName(String name)
- String getName()
- static Thread currentThread() 返回对当前正在执行的线程对象的引用
- static void sleep(long millis) 参数是毫秒,在哪个线程调用，就让哪一个线程进入休眠
- void interrupt() 通过产生异常的方式,中断线程的睡眠
示例程序：
public class ThreadTest04 {
public static void main(String[] args) {
Thread t1 = new Thread(new MyRunnable2());
Thread t2 = new Thread(new MyRunnable2());
//设置线程的名字
t1.setName("t1");
t2.setName("t2");
//获取线程的名字
System.out.println(t1.getName());
System.out.println(t2.getName());
t1.start();
t2.start();
}
}
class MyRunnable2 implements Runnable{
@Override
public void run() {
for (int i = 0; i < 1000; i++) {
Thread currentThread = Thread.currentThread();
System.out.println(currentThread.getName() +": " + i);
}
}
}
提前终止线程的方法
使用interrupt()方法
public class ThreadTest05 {
public static void main(String[] args) throws InterruptedException {
Thread t = new Thread(new Runnable() {
@Override
public void run() {
try {
Thread.sleep(1000 * 60 * 60 * 24);
} catch (InterruptedException e) {
e.printStackTrace();
}
Thread tmp = Thread.currentThread();
System.out.println(tmp.getName() + "线程 运行了");
}
});
//产生新的线程
t.setName("t");
t.start();
//主线程睡眠5s之后，叫醒t线程
Thread.sleep(1000 * 5);
//中断睡眠，通过产生异常的方式
t.interrupt();
}
}
设置标志信号量 -推荐
public class ThreadTest06 {
public static void main(String[] args) {
MyRunnable3 myRunnable3 = new MyRunnable3();
Thread t = new Thread(myRunnable3);
t.setName("t");
t.start();
//模拟5s后终止分支进程
try {
Thread.sleep(1000 * 5);
} catch (InterruptedException e) {
e.printStackTrace();
}
myRunnable3.run = false;
}
}
class MyRunnable3 implements Runnable{
boolean run = true;
@Override
public void run() {
for (int i = 0; i < 10; i++) {
if(run){
System.out.println(Thread.currentThread().getName() + "-->" + i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
} else {
return;
}
}
}
}
线程同步机制
什么情况下需要线程同步机制？
多个线程同时修改同一内存这的数据时会发生线程安全问题，需要线程同步机制。
正是因为这一点，所以局部变量一定不会存在线程安全问题。
线程同步代码块 synchronized()
()中传递的“数据”相当关键
这个数据必须是多线程共享的对象，才能达到多线程排队
假设只希望t1 t2 t3排队 t4 t5不需要排队
那么一定要在()写一个t1 t2 t3共享的对象，而这个对象对于t4 t5来说是不共享的
强调： 共享 对象
对象：参数应该是一个对象
共享：多个需要同步的线程执行到synchronized()检测的对象应该是同一个
举一个例子：字符串"abc"，那么所有线程都会检测字符串常量池中的"abc"，则所有线程都处于线程排队的状态
注意事项
-
同步代码块中的代码要尽可能的短小，提高执行效率
-
如果方法没有包含synchronized() 则此方法在执行的时候不会去锁池了寻找对象锁，会直接执行
-
在实例方法上可以使用synchronized修饰：
例如：public synchronized void withdraw(double money);
此时：锁默认是当前对象this,且方法体中全部的代码都需要同步;所以这种方法不灵活 -
如果synchronized修饰在静态方法上，表示类锁，类锁只有一把；而对象锁每一个对象都有一把
示例程序：
public class Accout {
private double balance;
public Accout() { }
public Accout(double balance) {
this.balance = balance;
}
public double getBalance() {
return balance;
}
public void setBalance(double balance) {
this.balance = balance;
}
public void withdraw(double money){
double after;
synchronized (this){
double before = getBalance();
after = before - money;
//模拟网络延迟1s
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
setBalance(after);
}
System.out.println(Thread.currentThread().getName() + "取款：" + money + " 余额： " + after);
}
}
public class AccoutThread {
public static void main(String[] args) {
MyRunnable mr = new MyRunnable(new Accout(1000));
//实例化两个取款线程类，模拟线程并发
Thread t1 = new Thread(mr);
Thread t2 = new Thread(mr);
t1.setName("t1");
t2.setName("t2");
t1.start();
t2.start();
}
}
//取款线程类
class MyRunnable implements Runnable{
private Accout accout;
public MyRunnable() {
}
public MyRunnable(Accout accout) {
this.accout = accout;
}
public Accout getAccout() {
return accout;
}
public void setAccout(Accout accout) {
this.accout = accout;
}
@Override
public void run() {
accout.withdraw(500);
}
}
总结 -解决线程安全问题的步骤？
-
synchronized会让程序的执行效率降低，则系统的用户吞吐量降低,用户体验差。在不得已的情况下再选择线程同步机制
-
第一种方案：尽量使用局部变量代替"实例变量"和"静态变量"
-
第二种方案：如果必须使用实例变量，那么可以考虑创建多个对象，这样实例变量的内存就不共享了
-
第三种方案：synchronized
