25/365 java 守护线程 线程同步 synchronized

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()); } }

• « 上一篇：使用Py6S计算瑞利反射率教程
• » 下一篇：C语言基础知识（33）