©2020-2024 ioDraw All rights reserved,
Privacy Policy
1.守护线程
线程分为守护线程和用户线程 ： daemon thread and non-daemon thread
虚拟机必须等待用户线程执行完毕，但无需等待守护线程执行完毕。
守护线程举例：垃圾回收线程，监控内存线程。
setDaemon(true):默认为false,默认为用户线程
public class D19 { public static void main(String[] args) { Thread thread =
new Thread(new A1()); thread.setDaemon(true); thread.start(); new Thread(new
A2()).start(); } } class A1 implements Runnable{ @Override public void run() {
while(true){ System.out.println("This is a daemon thread."); } } } class A2
implements Runnable{ @Override public void run() { for (int i = 0; i < 100;
i++) { System.out.println("This is a non-daemon thread."); }
System.out.println("The non-daemon thread has finished."); } }
A1并没有设置停止条件，但因为将它设置为了守护线程，所以程序可以正常结束。
2.线程同步
并发：多个线程操作一个对象
当多个线程操作同一个对象，并且有线程想要修改该对象时，就会出现线程同步的问题。
线程同步是一种等待机制，多个线程进入该对象的等待池形成队列，等待前一个线程使用完毕，下一个线程再使用。
使用线程和锁来保证线程同步的安全性。
锁机制：当一个线程获得锁，独占资源，其他线程必须等待，直到该线程使用完毕，释放锁。
问题：
* 等待该资源的对象挂起
* 加锁，释放锁导致更多的开销：上下文切换，调度延时
* 优先级倒置
3.运用synchronized关键字解决线程并发造成的不安全问题
1）synchronized关键字修饰方法，默认锁的是该方法的对象
使用前：
import org.omg.CORBA.TIMEOUT; public class D20 { public static void
main(String[] args) { Ticket ticket = new Ticket(); new Thread(ticket).start();
new Thread(ticket).start(); new Thread(ticket).start(); new
Thread(ticket).start(); } } class Ticket implements Runnable{ int ticketNum =
20; boolean flag = true; @Override public void run() { while(flag){ try {
buy(); } catch (InterruptedException e) { throw new RuntimeException(e); } } }
public void buy() throws InterruptedException { if(ticketNum<=0){ flag = false;
return; } Thread.sleep(100);
System.out.println(Thread.currentThread().getName()+" buy ticket: " +
ticketNum--); } }
不安全结果：多个对象取到相同的票
加入synchronized关键字
import org.omg.CORBA.TIMEOUT; public class D20 { public static void
main(String[] args) { Ticket ticket = new Ticket(); new Thread(ticket).start();
new Thread(ticket).start(); new Thread(ticket).start(); new
Thread(ticket).start(); } } class Ticket implements Runnable{ int ticketNum =
20; boolean flag = true; @Override public void run() { while(flag){ try {
buy(); } catch (InterruptedException e) { throw new RuntimeException(e); } } }
public synchronized void buy() throws InterruptedException { if(ticketNum<=0){
flag = false; return; } Thread.sleep(100);
System.out.println(Thread.currentThread().getName()+" buy ticket: " +
ticketNum--); } }
结果：不再出现取到同一张票的问题
2)用synchronized同步块
synchronized(Obj){ }
Obj为同步监视器，锁定代码块，同一时刻下只有一个线程访问该代码块
当synchronized修饰方法时，同步监视器默认为该方法的对象，也就是this
使用前：
import java.util.ArrayList; import java.util.List; public class D21 { public
static void main(String[] args) throws InterruptedException { List<String> list
= new ArrayList<String>(); for(int i=0;i<10000;i++){ new Thread(()->{
list.add(Thread.currentThread().getName()); } ).start(); } Thread.sleep(100);
System.out.println(list.size()); } }
不安全结果：多个线程向同一个地址写入数据，导致list的size不足10000
加入synchronized修饰代码块
import java.util.ArrayList; import java.util.List; public class D21 { public
static void main(String[] args) throws InterruptedException { List<String> list
= new ArrayList<String>(); for(int i=0;i<10000;i++){ new Thread(()->{
synchronized (list) { list.add(Thread.currentThread().getName()); } }
).start(); } Thread.sleep(100); System.out.println(list.size()); } }
结果：
java中有线程安全的ArrayList： CopyOnWriteArrayList
import java.util.concurrent.CopyOnWriteArrayList; public class D22 { public
static void main(String[] args) { CopyOnWriteArrayList<String> list = new
CopyOnWriteArrayList<>(); for (int i = 0; i < 10000; i++) { new Thread( ()->{
list.add(Thread.currentThread().getName()); } ).start(); } try {
Thread.sleep(1000); } catch (InterruptedException e) { throw new
RuntimeException(e); } System.out.println(list.size()); } }