什么是线程?

在同一个进程中可以执行多个任务,每一个任务可以看做一个线程.

线程是程序的执行单元,执行路径,使程序使用cpu的最基本单位

一个进程如果只有一条执行路径,那么就是单线程的

一个进程如果有多个执行路径,那么就是多线程的

多线程的意义:

多进程的存在是为了提高CPU的利用率,多线程的存在,不是为了提高程序的执行速度,而是为了提高应用程序的使用率.

程序的执行其实都是在抢CPU的资源,即CPU的执行权.

多个进程在抢这个资源,而其中一个进程如果有多个执行路径,即多个线程,那么就有更高的几率抢到CPU的执行权

JVM的启动是单线程的还是多线程的?

是多线程的,启动jvm是就相当于启动了一个进程,接着该进程会创建一个主线程来调用main方法,而同时还有启动其他的线程,比如说垃圾回收的线程.

两种方式实现多线程,一种是继承Thread类,一种是实现Runnable接口.以第一种为例:

package com.wang.reflect;
class MyThread extends Thread{

    @Override
    public void run() {
        for(int i=0;i<10;i++){
            //获取当前正在执行的线程的名称,相当于this.getName();
            System.out.println(Thread.currentThread().getName()+"::"+i);
        }
    }
}
public class TestReflect {
    public static void main(String[] args) throws Exception {
        MyThread mThread1=new MyThread();
        MyThread mThread2=new MyThread();
        //设置线程的名字,也可以直接通过带参构造函数设置线程名称
        mThread1.setName("张无忌:");
        mThread2.setName("赵敏:");
        mThread1.start();
        mThread2.start();
        for(int i=0;i<10;i++){
            System.out.println(Thread.currentThread().getName()+"::"+i);
        }
    }


}

一般我们使用第二种方式实现多线程,实现Runnable接口的方式相比较继承Thread类的方式有两个好处:

1.避免由于java单继承带来的局限性.

2.适合多个相同程序的代码去处理同一个资源的情况,把线程同程序的代码,数据,有效分离,较好地体现了面向对象的思想.

线程调度:

线程有两种调度模型:

1.分式调度模型,所有的线程轮流使用CPU的使用权,平均分配每个线程占用的CPU时间片.

2.抢占式调度模型,优先让优先级高的线程先执行,如果优先级相同,那么随机选择一个线程,优先级高的线程获得CPU的执行权的几率大一些,并不是严格按照优先级由高到低执行.

java使用的是抢占式调度模型.

方法介绍:

获取当前线程对象的优先级,默认优先级为5,范围是1~10 int  getPriority()
设置当前线程的优先级,范围1~10    void  setPriority()
在指定毫秒内让正在运行的线程休眠(暂停执行) static void sleep(1000)
----------------------------------------------------- -----------------------------------
等待当前线程执行结束,该方法一般紧随start()方法之后 final void join()
暂停当前正在执行的对象,执行其他线程,(礼让线程) static void yield()

将该线程标记为守护线程或用户线程。

当正在运行的线程都是守护线程时,Java 虚拟机退出。

该方法必须在启动线程前调用。

final void setDaemon(true)

看这张图,来更好的理解守护线程:

假设现在有三个线程分别叫关羽,刘备,张飞.将关羽,张飞设置为守护线程,一旦刘备这个线程执行完毕(死掉),那么关羽,张飞也就没有活着的意义了(不再执行,退出).

中断线程,把线程状态终止,并抛出一个InterruptedException         void interrupt()

线程的生命周期:

案例练习:

电影院卖票,假设有三个窗口同时卖票,共有100张票,用多线程模拟这个过程(要解决的关键问题是:线程同步).

package com.wang.reflect;
class SellTicket implements Runnable {
    // 共享变量
    private int tickets = 100;
    // 创建锁对象
    private Object obj = new Object();
    @Override
    public void run() {
        while (true) {
            /**
             * 解决线程同步问题的 方案:
             *     synchronized(锁对象){
             *        //操作共享变量的代码
             *  }
             *
             */
            synchronized (obj) {
                if (tickets > 0) {
                    System.out.println(Thread.currentThread().getName()
                            + "正在出售第" + (tickets--) + "张票");
                }
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }

        }
    }
}
public class SellTicketDemo {
    public static void main(String[] args) {
        SellTicket st = new SellTicket();
        Thread t1 = new Thread(st, "窗口1");
        Thread t2 = new Thread(st, "窗口2");
        Thread t3 = new Thread(st, "窗口3");
        t1.start();
        t2.start();
        t3.start();
    }
}

打印结果如下:

synchronized是一个关键字.可以加在一段代码外部,也可以放在一个方法前.它的锁对象可以是任意对象,当然也可以写成当前类的对象this.

  • 同步代码块的锁对象:任意对象
  • 同步方法的锁对象:当前对象this
  • 同步静态方法的锁对象:当前类的字节码对象,类名.class;

java类库中线程安全的类有:StringBuffer,HashTable,Vector.

注意Vector是线程安全的,但是当我们需要一个线程安全的集合的时候,我们一般也不用它,在Collections类中获取线程安全的list集合的方法,假设我们现在需要获得一个线程安全的List<String>集合,可以这样写:

List<String> list=Collections.synchronizedList(new ArrayList<String>());

虽然说我们可以理解同步代码块和同步方法的锁对象问题,但我们并没有直接看到在哪儿加上锁又在哪儿释放锁,为了更清晰的表达如何加锁和释放锁,JDK1.5以后提供了一个新的锁对象Lock.下面通过Lock锁实现上述卖票的过程.

package com.wang.reflect;
import java.util.ArrayList;
import java.util.Collections;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
class SellTicket implements Runnable {
    // 共享变量
    private int tickets = 100;
    // Lock是一个接口,ReentrantLock是他的一个实现类
    private Lock lock=new ReentrantLock();
    @Override
    public void run() {
        while (true) {
            lock.lock();//加锁
            if (tickets > 0) {
                System.out.println(Thread.currentThread().getName() + "正在出售第"
                        + (tickets--) + "张票");
            }
            lock.unlock();//释放锁
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
public class SellTicketDemo {
    public static void main(String[] args) {
        SellTicket st = new SellTicket();
        Thread t1 = new Thread(st, "窗口1");
        Thread t2 = new Thread(st, "窗口2");
        Thread t3 = new Thread(st, "窗口3");
        t1.start();
        t2.start();
        t3.start();
    }
}

线程同步有两个很明显的弊:一是效率低,二是容易产生死锁.

死锁问题:

两个或两个以上的线程,在争夺资源的过程中,发生的一种相互等待的过程.下面通过代码演示死锁问题的存在:

package com.wang.reflect;
class DieLock extends Thread{
    private boolean flag;
    public DieLock(boolean flag){
        this.flag=flag;
    }
    public static final Object o1=new Object();
    public static final Object o2=new Object();
    @Override
    public void run() {
        if(flag){
            synchronized(o1){
                System.out.println("if o1");
                synchronized (o2) {
                    System.out.println("if o2");
                }
            }

        }else{
            synchronized (o2) {
                System.out.println("else o2");
                synchronized (o1) {
                    System.out.println("else o1");
                }
            }
        }
    }
}
public class DieLockDemo {
    public static void main(String[] args) {
        DieLock dl1=new DieLock(true);
        DieLock dl2=new DieLock(false);
        dl1.start();
        dl2.start();
    }
}

细读代码,可以发现,理想状态下,应该会打印:

if o1

if o2

else o2

else o1

但是运行之后,发现打印结果大多为:

if o1             或者     else o2

else o2                    if  o1

其实这里就发生了线程互相等待,也就是死锁问题.

生产者-消费者模式描述:

package com.wang.reflect;
//学生实体类作为共享资源
class Student{
    String name;//姓名
    int age;//年龄
    boolean flag;//标记变量,判断当前学生对象是否已创建赋值好

}
//模拟生产者线程类
class SetStudent implements Runnable{
    //共享资源s
    private Student s;
    private int x=0;

    public SetStudent(Student s) {
        this.s=s;
    }

    @Override
    public void run() {
        while(true){

            synchronized (s) {
                if(s.flag){
                    try {
                        s.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

                if(x%2==0){
                s.name="郭靖";
                s.age=24;
                }else{
                    s.name="黄蓉";
                    s.age=18;
                }
                x++;
                //生产完之后,将标记置为true,通知消费者来消费
                s.flag=true;
                //唤醒线程
                s.notify();
            }
        }
    }

}
//模拟消费者线程类
class GetStudent implements Runnable{
        //共享资源s
        private Student s;


        public GetStudent(Student s) {
            this.s=s;
        }
    @Override
    public void run() {
        while(true){
            synchronized (s) {
                if(!s.flag){
                    try {
                        s.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println(s.name+":::"+s.age);

                //消费完以后将标记之置于false,通知生产者来生产
                s.flag=false;
                //唤醒线程
                s.notify();
            }
        }
    }
}
//测试类
public class StudentDemo {
    public static void main(String[] args) {
        Student s =new Student();

        SetStudent ss=new SetStudent(s);
        GetStudent gs=new GetStudent(s);

        Thread t1=new Thread(ss, "生产者");
        Thread t2=new Thread(gs, "消费者");

        t1.start();
        t2.start();
    }
}

在上面的代码中,生产者就是代表对Student属性进行赋值,消费者就是代表对Studnet属性进行打印,代码设置了等待唤醒机制.

上述代码可以优化的,可以讲生产者的赋值行为,和消费者的打印行为,封装到Student类中,写成两个同步方法.实现这两个功能.代码如下:

package com.wang.reflect;
//学生实体类作为共享资源
class Student {
    private String name;// 姓名
    private int age;// 年龄
    boolean flag;// 标记变量,判断当前学生对象是否已创建赋值好
    public synchronized void set(String name, int age) {
        if (this.flag) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        this.name = name;
        this.age = age;
        this.flag = true;
        this.notify();
    }
    public synchronized void get() {
        if (!this.flag) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println(name + ":::" + age);
        this.flag = false;
        this.notify();
    }
}
// 模拟生产者线程类
class SetStudent implements Runnable {
    // 共享资源s
    private Student s;
    private int x = 0;
    public SetStudent(Student s) {
        this.s = s;
    }
    @Override
    public void run() {
        while (true) {
            if (x % 2 == 0) {
                s.set("郭靖", 27);
            } else {
                s.set("黄蓉", 18);
            }
            x++;
        }
    }
}
// 模拟消费者线程类
class GetStudent implements Runnable {
    // 共享资源s
    private Student s;
    public GetStudent(Student s) {
        this.s = s;
    }
    @Override
    public void run() {
        while (true) {
            s.get();
        }
    }
}
// 测试类
public class StudentDemo {
    public static void main(String[] args) {
        Student s = new Student();
        SetStudent ss = new SetStudent(s);
        GetStudent gs = new GetStudent(s);
        Thread t1 = new Thread(ss, "生产者");
        Thread t2 = new Thread(gs, "消费者");
        t1.start();
        t2.start();
    }
}

转载于:https://www.cnblogs.com/fingerboy/p/5347314.html

java多线程--多线程基础小结相关推荐

  1. java的 0x7f_Java基础小结

    JavaSE基础 本文为作者在学习和笔试题中遇到的小知识点总结,做以总结和备用. jdk的安装和配置环境变量 (1)以win10为例,右键此电脑,选择属性,进去系统设置,选择高级系统设置,进入环境变量 ...

  2. java mina多线程_Java多线程基础总结九:Mina窥探(1)

    一直以来的多线程的基础总结都是脱离应用的,但是要说多线程的应用就不能不说Mina.Apache Mina作为一个高性能的Java异步并发网 络通讯框架,其内部的多线程的设计和实现可谓是学习多线程的良药 ...

  3. java 并发编程多线程_多线程(一)java并发编程基础知识

    线程的应用 如何应用多线程 在 Java 中,有多种方式来实现多线程.继承 Thread 类.实现 Runnable 接口.使用 ExecutorService.Callable.Future 实现带 ...

  4. 【零基础学Java】—多线程(四十九)

    [零基础学Java]-多线程(四十九) 一.并发与并行 并发:指两个或多个事件在同一时间段内发生 并行:指两个或多个事件在同一时刻发生(同时发生) 二.进程和线程

  5. java多线程并发基础汇总一

    一.java并发线程基础 文章目录 一.java并发线程基础 1.1 什么是线程 1.2 线程的创建方式 1.3 Object类中的方法:线程通知与等待 1.4 Thread类中的方法 1.4.1 等 ...

  6. JavaSE基础二十:Java 多线程(线程基础知识、Java 多线程、Java 实现多线程(继承 Thread 类、实现 Runnable 接口、实现 Callable 接口))

    本章目录 1.基础知识准备 2.Java 多线程概述 3.Java 实现多线程 3.1.继承 Thread 类 如何开启新线程 Thread 类常用方法 多线程中的同步 Thread 类同步方法 多线 ...

  7. 关于Java的多线程Runnable的个人理解(基础,不讲概念)

    背景说明: 在学了Java的多线程(继承Thread,Runnable)以后,我出于好奇,就想知道java到底是不是多线程的,不能它说自己是多线程就是多线程,自己想验证一下,于是我就想测试一下,但继承 ...

  8. java核心-多线程-Java多线程编程涉及到包、类

    Java有关多线程编程设计的类主要涉及两个包java.lang和java.util.concurrent两个包 java.lang包,主要是线程基础类 <1>Thread<2> ...

  9. Java的多线程机制系列:(四)不得不提的volatile及指令重排序(happen-before)

    一.不得不提的volatile volatile是个很老的关键字,几乎伴随着JDK的诞生而诞生,我们都知道这个关键字,但又不太清楚什么时候会使用它:我们在JDK及开源框架中随处可见这个关键字,但并发专 ...

  10. Java面试之多线程:Java创建多线程为什么只有一种方式?

    关于线程的创建,其实我一直都有话说,于是今天,我来开个头.今天依旧一样,长话短说,只谈创建多线程.你好,我是fntp!今天要跟大家分享的是博主最近面试Java实习所遇到的一些问题!那就是经常性被问到的 ...

最新文章

  1. 从LSTM到GRU基于门控的循环神经网络总结
  2. 传统KTV向互联网+量贩式低头,KTV也需O2O
  3. 剑指offer: 替换空格 python实现
  4. 通信原理之IP协议,ARP协议 (三)
  5. cakephp 安装mysql_CakePHP的安装的简单方法
  6. VC++下命名管道编程的原理及实现
  7. 介绍MyBatis代码生成网站(四) --- 继承基类
  8. Web前端开发学习资料分享
  9. Jumpserver web界面跳板机
  10. 【java虚拟机系列】JVM类加载器与ClassNotFoundException和NoClassDefFoundError
  11. 最大规模传统零售升级揭晓 100家大润发线上线下同步加入天猫618
  12. [BZOJ2157]旅游(树链剖分/LCT)
  13. HTML中,使用hover属性完成鼠标悬停切换图片效果
  14. dvi一分四_【1进4出DVI分配器】
  15. thingworx ADO安装
  16. Python实现自动给视频打码,减少不宜画面出现...
  17. 明明都保意外,定期寿险和意外险到底区别在哪里?
  18. 【机器学习】模型评估
  19. ffmpeg-时间基tbn、tbc、tbr
  20. 【CYH-02】NOIp考砸后虐题赛:函数:题解

热门文章

  1. mysql修改默认编码为UTF8
  2. [leetcode] Pow(x, n)
  3. 利用命令清除和设定静态IP地址
  4. Hadoop的Python语言封装
  5. IT技术能治病救人-数据是21世纪最伟大的药物
  6. Greenplum数据库(GPDB)初识
  7. mysql表数据以本地文件方式导入Hive
  8. thymeleaf模板的使用——1,thymeleaf概述|| thymeleaf 的使用方法|| 如何修改Thymeleaf的默认存放地址||Thymeleaf的相关语法
  9. 二维数组||考试成绩统计: 案例描述:有三名同学(张三,李四,王五),在一次考试中的成绩分别如下表,请分别输出三名同学的总成绩
  10. 用javascript实现简单的物质(密度)分布图