并发编程-多线程基础

上一篇 <<<安全架构设计方案
下一篇 >>>线程安全与解决方案


多线程: 在同一个进程开启了多条不同的执行路径,每条执行路径就是一个线程,多条不同路径同时执行。

优点:
a、提高程序效率 (是否真正实现多线程是看CPU核数的,对于单核的CPU,程序多线程只不过是调度不断的切换,时间非常的小而产生的一种错觉。所以线程设置优先级、让步等基本上都行不通的。
b、快速响应给客户端,给用户更加好的体验
c、每个线程之间相互不影响

进程和线程区别

进程是所有线程的集合,每一个线程是进程中的一条执行路径,线程只是一条执行路径。

单线程和多线程的区别

单线程:就是使用一条线程从上到下执行完代码,效率比较低,且响应也比较慢,对用户不是很友好。
多线程:开启多条不同的线程,每个线程执行不同的任务,每个线程之间相互不影响。

多线程创建方式

  • 继承Thread
  • 实现Runnable 接口
  • 使用Callable--可以有返回值
  • 线程池--线程的复用机制
  • @Async注解---存在@Async失效之谜

继承Thread类好还是实现Runnable接口好?
Runnable接口好,因为实现了接口还可以继续继承。
继承Thread类不能再继承。

多线程的特性

  • 原子性

一个操作或多个操作要么都执行,要么都不执行。

  • 可见性

多线程访问同一个变量时,一个线程修改了值,其他线程应该立即看到修改的值,否则容易造成脏读。[若两个线程在不同的cpu,那么线程1改变了i的值还没刷新到主存,线程2又使用了i,那么这个i值肯定还是之前的,线程1对变量的修改线程没看到这就是可见性问题。 ]

  • 有序性

处理器为了提高程序运行效率,可能对输入代码的顺序有优化,但不能修改依赖关系,必须要保证执行结果。多线程如果顺序不弄好,单个方法没依赖关系,但全局有依赖关系就会导致很大问题。

int a = 10;    //语句1
int r = 2;    //语句2
a = a + 3;    //语句3
r = a*a;     //语句4
则因为重排序,他还可能执行顺序为 2-1-3-4,1-3-2-4
但绝不可能 2-1-4-3,因为这打破了依赖关系。

多线程的应用场景

  • 分批发送短信
  • 日志记录
  • 比较耗时的业务独立处理
  • 数据库连接池
  • 迅雷多线程下载等。

线程的类型

  • 主线程:main线程/进程线程
  • 守护线程:gc线程 (主线程挂了,守护线程也会被自动销毁.)
  • 用户线程:用户自己创建的线程(主进程关闭后还会继续执行
public static void main(String[] args) {
    Thread t1 = new Thread(new Runnable() {
        public void run() {
            for(int i=0;i<10;i++){
                System.out.println("子线程 i:"+i);
            }
        }
    });
    t1.start();
    System.out.println("主线程已关闭");
}
主线程已关闭
子线程 i:0
子线程 i:1
子线程 i:2
……

使用setDaemon(true)方法可以将用户线程转为守护线程,和主线程一起销毁

public class DaemonThread {

   public static void main(String[] args) {
      Thread thread = new Thread(new Runnable() {
         public void run() {
            while (true) {
               try {
                  Thread.sleep(100);
               } catch (Exception e) {
                  // TODO: handle exception
               }
               System.out.println("我是子线程...");
            }
         }
      });
      thread.setDaemon(true);
      thread.start();
      for (int i = 0; i < 10; i++) {
         try {
            Thread.sleep(100);
         } catch (Exception e) {

         }
         System.out.println("我是主线程");
      }
      System.out.println("主线程执行完毕!");
   }
}
我是子线程...
我是主线程
主线程执行完毕!

多线程的状态

如何优雅的停止一个线程

// 设置可见性
private volatile boolean flag = true;
public void run() {
    System.out.println(Thread.currentThread().getName());
    // 能保证在线程执行完毕后,才真正的停止一个线程
    while (flag) {

    }
}

public void stopThread() {
    this.flag = false;
}

其他知识

a、join方法:join方法对应的线程执行完毕后,后面的才可以继续执行

public static void main(String[] args) {
   final Thread t1 = new Thread(new Runnable() {
      public void run() {
         for (int i = 0; i < 5; i++) {
            System.out.println("t1,i:" + i);
         }
      }
   });
   final Thread t2 = new Thread(new Runnable() {
      public void run() {
         try {
            t1.join();
         } catch (Exception e) {
         }
         for (int i = 0; i < 5; i++) {
            System.out.println("t2,i:" + i);
         }
      }
   });
   t1.start();
   t2.start();
}
t1,i:0
t1,i:1
t1,i:2
t1,i:3
t1,i:4
t2,i:0
t2,i:1
t2,i:2
t2,i:3
t2,i:4

b、priority优先级设置,范围为1-10,其中10最高,默认值为5。

public static void main(String[] args) {
    PrioritytThread prioritytThread = new PrioritytThread();
    Thread t1 = new Thread(prioritytThread);
    Thread t2 = new Thread(prioritytThread);
    t1.start();
    // 注意设置了优先级, 不代表每次都一定会被执行。 只是CPU调度会优先分配
    t1.setPriority(10);
    t2.start();
}

c、Thread.yield(),暂停当前正在执行的线程,并执行其他相同优先级的线程。目的是让具有相同优先级的线程之间能够适当的轮换执行。
可能没有效果,因为让步的线程可能被线程调度程序再次选中。

多线程产生死锁的原因

同步中嵌套同步,导致锁无法释放和获取

死锁诊断

使用jdk自带的jconsole工具即可


相关文章链接:
<<<线程安全与解决方案
<<<锁的深入化
<<<锁的优化
<<<Java内存模型(JMM)
<<<Volatile解决JMM的可见性问题
<<<Volatile的伪共享和重排序
<<<CAS无锁模式及ABA问题
<<<Synchronized锁
<<<Lock锁
<<<AQS同步器
<<<Condition
<<<CountDownLatch同步计数器
<<<Semaphore信号量
<<<CyclicBarrier屏障
<<<线程池
<<<并发队列
<<<Callable与Future模式
<<<Fork/Join框架
<<<Threadlocal
<<<Disruptor框架
<<<如何优化多线程总结

推荐阅读更多精彩内容