java多线程基础学习[狂神说java-多线程笔记]

最新推荐文章于 2023-01-13 17:08:19 发布
最新推荐文章于 2023-01-13 17:08:19 发布
阅读量1k 收藏 17
点赞数 3
分类专栏： java学习 文章标签： 多线程 java 并发编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Alivorth/article/details/109565988
版权

java多线程基础学习

一、线程简介


所有的资料来源都是以【狂神说Java】多线程详解为基础
【狂神说Java】多线程详解
建议看视频，这篇博客是笔记
同时要结合目录看


1.类比

类比于现实中的的多任务，在同一个时间段，同时做几件事情

在程序中就是主线程与子线程同时进行任务


2.程序进程线程

在操作系统中的运行的程序就是进程，而进程通常采用多进程执行

  • 程序

    指令和数据的有序集合，本身没有任何运行的含义，是静态概念

  • 进程

    是执行程序的一次执行过程，是一个动态概念，是系统资源分配的单位

  • 线程

    一个进程通常包括多个线程，线程是CPU调度和执行的单位


3.线程的核心概念

在这里插入图片描述





二、线程的实现(重点)


调用方法与调用多线程的区别

run()方法是需要执行的方法体

start()方法是开启多线程的方法体

在这里插入图片描述




Thread 类

不建议使用：避免OOP单继承局限性


1.thread使用方法

  1. 自定义线程类继承Thread类
  2. 重写run方法，编写线程执行体
  3. 在主线程中创建线程对象，使用start方法启动线程

2. 代码实现

package cn.livorth;

public class TestThread01  extends Thread{
    @Override
    public void run() {
        //在run()方法中编写执行体
        for (int i = 0; i < 100; i++) {
            System.out.println("在子线程中执行--" + i);
        }
    }

    public static void main(String[] args) {
        //在主线程中创建线程对象，使用start方法启动线程
        TestThread01 testThread = new TestThread01();
        testThread.start();

        for (int i = 0; i < 100; i++) {
            System.out.println("在主线程中执行---" + i);
        }

    }
}

效果如下:

并行交替执行，轮流占用cpu

在这里插入图片描述


3.应用

样例来自《狂神说java-多线程详解》

代码（详解在注释）：

package cn.livorth;

import org.apache.commons.io.FileUtils;

import java.io.File;
import java.io.IOException;
import java.net.URL;

public class TestThread02 extends Thread{

    private String url;
    private String filename;

    //构造函数传入所需的url和filename
    public TestThread02(String url, String filename) {
        this.url = url;
        this.filename = filename;
    }

    @Override
    public void run() {
        //调用downLoader来获取文件
        webDownLoader webDownLoader = new webDownLoader();
        webDownLoader.downLoader(url, filename);
        System.out.println(filename + "下载完成");
    }


    public static void main(String[] args) {
        //传入三张图图片的url
        TestThread02 t1 = new TestThread02("https://i0.hdslb.com/bfs/album/" +
                "481ba607ba31e9932b90e383f3698fec4c1d9577.jpg@518w_1e_1c.jpg", "pic01.jpg");
        TestThread02 t2 = new TestThread02("https://i0.hdslb.com/bfs/album/" +
                "98d71302c030aa86258eb17a5db084bfadf8ff39.jpg@518w_1e_1c.jpg", "pic02.jpg");
        TestThread02 t3 = new TestThread02("https://i0.hdslb.com/bfs/album/" +
                "70849f611883c3e7feffc730c4f1e7b7173c9695.jpg@518w_1e_1c.jpg", "pic03.jpg");

        //开始多线程下载
        t1.start();
        t2.start();
        t3.start();
    }
}

class webDownLoader
{
    /**
     * 通过url获取文件内容，并保存
     * @param url
     * @param name
     */
    public void downLoader(String url, String name)
    {

        try {
            //调用Commons_io包里面的方法copyURLToFile
            FileUtils.copyURLToFile(new URL(url),  new File(name));
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("IO异常，downLoader出现问题");
        }
    }
}

结果：

在这里插入图片描述

这只是一个简单的对多线程的小实践，事实上通过这样获取图片还是有诸多问题




Runnable 接口

推荐使用：避免单继承的局限性，方便同一个对象被多个进程调用



1.Runable使用方法

  1. 自定义MyRunable类实现Runable接口
  2. 重写run方法，编写线程执行体
  3. 在主线程中创建线程对象，使用start方法启动线程

2. 代码实现

package cn.livorth;

public class TestThread03 implements Runnable{
    @Override
    public void run() {
        //在run()方法中编写执行体
        for (int i = 0; i < 100; i++) {
            System.out.println("在子线程中执行--" + i);
        }
    }

    public static void main(String[] args) {
        //创建Runable接口的实现类对象
        TestThread03 testThread = new TestThread03();
        //创建线程对象，通过线程对象来开启线程，也就是代理
        Thread thread =  new Thread(testThread);
        thread.start();

        //也可以缩写为：
        //new Thread(testThread).start();

        for (int i = 0; i < 100; i++) {
            System.out.println("在主线程中执行---" + i);
        }

    }
}

效果如下：

在实现的效果上是没有区别的：
在这里插入图片描述


3.应用

按照狂神说的那个样例来的话，会出现问题

对个线程操作同一个资源的时候，线程不安全，数据会紊乱
所以不写了




Callable接口

仅作了解即可

1.Callable使用方法

通过服务提交线程

  1. 实现Callable接口，需要返回值类型
  2. 重写call方法， 需要抛出异常
  3. 创建目标对象
  4. 创建执行服务: ExecutorService ser = Executors.newFixedThreadPool(1);
  5. 提交执行: Future result1 = ser.submit(t1);
  6. 获取结果: boolean r1 = result1.get()
  7. 关闭服务: ser.shutdownNow();

2.代码实现

改自Thread中的应用

《狂神说java-多线程详解》-P8

package cn.livorth;

import java.util.concurrent.*;

public class TestCallable01 implements Callable<Boolean> {
    private String url;
    private String filename;

    //构造函数传入所需的url和filename
    public TestCallable01(String url, String filename) {
        this.url = url;
        this.filename = filename;
    }

    @Override
    public Boolean call() {
        //调用downLoader来获取文件
        webDownLoader webDownLoader = new webDownLoader();
        webDownLoader.downLoader(url, filename);
        System.out.println(filename + "下载完成");
        return true;
    }


    public static void main(String[] args) {
        //传入三张图图片的url
        TestCallable01 t1 = new TestCallable01("https://i0.hdslb.com/bfs/album/" +
                "481ba607ba31e9932b90e383f3698fec4c1d9577.jpg@518w_1e_1c.jpg", "pic01.jpg");
        TestCallable01 t2 = new TestCallable01("https://i0.hdslb.com/bfs/album/" +
                "98d71302c030aa86258eb17a5db084bfadf8ff39.jpg@518w_1e_1c.jpg", "pic02.jpg");
        TestCallable01 t3 = new TestCallable01("https://i0.hdslb.com/bfs/album/" +
                "70849f611883c3e7feffc730c4f1e7b7173c9695.jpg@518w_1e_1c.jpg", "pic03.jpg");

        //创建执行服务(参数为线程池的大小)
        ExecutorService service = Executors.newFixedThreadPool(3);

        //提交执行
        Future<Boolean> r1 = service.submit(t1);
        Future<Boolean> r2 = service.submit(t2);
        Future<Boolean> r3 = service.submit(t3);

        //获取结果(不写应该也是可以的，这里应该是作为一种检验参数)
        try {
            boolean rs1 = r1.get();
            boolean rs2 = r2.get();
            boolean rs3 = r3.get();

            System.out.println(rs1);
            System.out.println(rs2);
            System.out.println(rs3);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }

        //关闭服务
        service.shutdown();

    }
}

结果：

在这里插入图片描述




三、线程的状态

线程的5个状态

在这里插入图片描述

  1. 创建状态：Thread t = new Thread();
  2. 就绪状态：调用start方法
  3. 运行状态：被cpu调度执行
  4. 阻塞状态：调用sleep、wait或同步锁定时，进入阻塞状态
  5. 死亡状态：线程中断或者结束，一旦死亡就不再启动


线程方法

方法说明
setPriority(int newPriority)更改线程的优先级
static void sleep(long millis)在指定的毫秒数内让当前正在执行的线程休眠
void join()等待该线程终止
static void yield()暂停当前正在执行的线程对象，并执行其他线程
void interrupt()中断线程，别用这个方式
boolean isAlive()测试线程是否处于活动状态

  1. 停止线程

    • 不推荐使用JDK提供的stop()、destroy()。

    • 推荐让线程自己停下来，但也不建议使用死循环

    • 建议使用一个标志位作为终止变量，当flag==false时，线程终止运行

    package cn.livorth.state;

public class TestStop implements Runnable{

    private boolean flag = true;

    @Override
    public void run() {
        int i = 0;
        while(flag)
        {
            System.out.println("子进程执行中---" + i++);
        }
    }

    //设置个公开方法，利用标志位停止线程
    public void stop(){
        this.flag = false;
    }

    public static void main(String[] args) {
        TestStop testStop = new TestStop();
        new Thread(testStop).start();

        for (int i = 0; i < 100; i++) {
            System.out.println("主进程执行中---" + i);

            if(i == 90){
                testStop.stop();
                System.out.println("子进程结束运行");
            }
        }
    }
}

  2. 线程休眠

    • sleep()方法的单位是毫秒

    • sleep()存在异常InterruptedException

    • sleep完了线程进入就绪状态，不会直接进入执行态

    • 可以用于模拟网络延时，倒计时等

    • 每个对象都有一个锁，sleep不释放锁

            try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    模拟网络延时可以放大问题的发生性

  3. 线程礼让

    • 礼让不一定成功，yield方法是当前正在执行的进程进入就绪态，等待cpu的调度
    public void run() {
   System.out.println(Thread.currentThread().getName()+"线程开始执行");
   Thread.yield();//礼让
   System.out.println(Thread.currentThread().getName()+"线程停止执行");
}

  4. Join

    join合并线程，只能是当前线程执行完之后才能执行其他线程，对其他线程造成阻塞

    package cn.livorth.state;

public class TestJoin implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println("子线程执行---" + i);
        }
    }


    public static void main(String[] args) {
        TestJoin testJoin = new TestJoin();
        Thread thread = new Thread(testJoin);
        thread.start();


        for (int i = 0; i < 500; i++) {
            if(i == 200)
            {
                try {
                    //阻塞主线程，使子线程优先执行完
                    thread.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("主线程执行---" + i);
        }
    }
}


观察线程的状态

在这里插入图片描述

代码样例：

package cn.livorth.state;

public class TestState {
    public static void main(String[] args) {
        Thread thread  = new Thread(()->{
            for (int i = 0; i < 5; i++) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("******");
            }
        });

        //启动前
        Thread.State state = thread.getState();
        System.out.println(state);//NEW

        //启动后
        thread.start();
        state = thread.getState();
        System.out.println(state);//RUNABLE

        //阻塞时与结束时
        while(state != Thread.State.TERMINATED){
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            state = thread.getState();
            //TIMED_WAITING或者TERMINATED
            System.out.println(state);
        }
    }
}

结果样例：
在这里插入图片描述



线程的优先级

  • Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度器按照优先级决定应该调度哪个线程来执行。

  • 线程的优先级用数字表示，范围从1~10.

    • Thread.MIN_ PRIORITY= 1;
    • Thread.MAX PRIORITY = 10;
    • Thread.NORM_ PRIORITY= 5;

  • 使用以下方式获取或改变优先级

    • getPriority() ，setPriority(int xxx)

注意：

  1. 先设置优先级再启动

  2. main方法的默认优先级为5

  3. 理论上来说优先级越高的越先执行，哪怕他start更晚

守护线程（daemon）

  • 线程分为用户线程和守护线程
  • 虚拟机必须确保用户线程执行完毕.
  • 虚拟机不用等待守护线程执行完毕
  • 如，后台记录操作日志，监控内存，垃圾回收等待…

代码示例：

package cn.livorth.state;

public class TestDaemon {
   public static void main(String[] args) {
       God god = new God();
       You you = new You();

       Thread thread = new Thread(god);
       //将上帝设置为守护线程，在false的时候为用户线程
       thread.setDaemon(true);
       thread.start();

       //开启一般的用户线程
       new Thread(you).start();
   }
}


class God implements Runnable{

   @Override
   public void run() {
       //上帝永生，无限循环
       while (true)
           System.out.println("上帝在你身旁");
   }
}


class You implements Runnable{

   @Override
   public void run() {
       //人生有限，100年后撒手人寰
       for (int i = 0; i < 100; i++) {
           System.out.println("happy everyday");
       }
       System.out.println("goodbye world");
   }
}

结果：

在这里插入图片描述

上帝明明是个死循环，但是进程还是结束了。

因为这里将上帝线程设置为了守护线程，虚拟机不加以考虑




四、线程同步

并发：同一个对象被多个线程同时操作，也就是不同线程同时操作同一个资源地址，造成数据紊乱

同步：多个需要同时访问资源的线程进入对象的等待池，等待前面线程使用完毕

锁：每个对象都有把锁，当获取对象时，独占资源，其他线程必须等待，使用结束后才释放

  • 一个线程持有锁会导致其他所有需要此锁的线程挂起
  • 在多线程竞争下，加锁，释放锁会导致比较多的上下文切换和调度延时，引起性能问题
  • 如果一个优先级高的线程等待一个优先级低的线程释放锁，会导致优先级倒置，引起性能问题


同步方法与同步块

synchronized关键字

synchronized默认锁的是他自身的对象，要是跨对象，通常使用同步块，即锁共享资源所在的对象

  1. 同步方法

    public synchronized void method(int args){}

    因为每个对象对应一把锁，使用加了关键字之后，方法一旦执行就独占该锁

    缺陷:若将一个大的方法申明为synchronized将会影响效率

  2. 同步块

    synchronized(Obj){}
  • Obj称之为同步监视器
    • Obj可以是任何对象,但是推荐使用共享资源作为同步监视器
    • 同步方法中无需指定同步监视器,因为同步方法的同步监视器就是this ,就是这个对象本身或者是class [反射中讲解]
  • 同步监视器的执行过程:
    1. 第一个线程访问,锁定同步监视器,执行其中代码.
    2. 第二个线程访问 ，发现同步监视器被锁定,无法访问
    3. 第一个线程访问完毕 ,解锁同步监视器.
    4. 第二个线程访问，发现同步监视器没有锁，然后锁定并访问


死锁

多个线程各自占有一些共享资源,并且互相等待其他线程占有的资源才能运行,而导致两个或者多个线程都在等待对方释放资源,都停止执行的情形. 某一个同步块同时拥有“两个以上对象的锁”时,就可能会发生“死锁”的问题.

我的理解：

​ 张三占用着A资源，等着B资源，李四占用着B资源，等着A资源

​ 张三同时有AB资源才能完成任务，李四也一样，但是两个人谁都不会先放手

​ 然后就进入了死锁

产生死锁的四个必要条件:

  1. 互斥条件: 一个资源每次只能被一个进程使用
  2. 请求与保持条件: 一个进程因请求资源而阻塞时，对已获得的资源保持不放
  3. 不剥夺条件: 进程已获得的资源，在末使用完之前，不能强行剥夺
  4. 循环等待条件: 若干进程之间形成一种头尾相接的循环等待资源关系

只要破除任意一个就能避免死锁



Lock(锁)

通过显示定义同步锁对象（Lock）来实现同步

ReentrantLock类实现了Lock接口，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock,可以显式加锁、释放锁。

演示代码：

package cn.livorth.gaoji;

import java.util.concurrent.locks.ReentrantLock;

public class TestLock {

    public static void main(String[] args) {
        TestLock2 testLock = new TestLock2();

        new Thread(testLock, "A").start();
        new Thread(testLock, "B").start();
        new Thread(testLock, "C").start();
    }

}

class TestLock2 implements Runnable{
    int count = 1000;

    //定义lock锁
    private final ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        while(true)
        {
            try {
                //进入加锁状态
                lock.lock();
                if(count > 0)
                    System.out.println(Thread.currentThread().getName() + "---" +count--);
                else
                    break;
            }
            finally {
                //解锁
                lock.unlock();
            }
        }
    }
}

说明：

在不加锁的情况下，ABC可能会同时操作到count，导致数据紊乱

在加了锁之后，ABC排队操作




五、线程协作

生产者消费者模式

有一说一这个我们上个学期的操作系统讲的很详细了

生产者与消费者共享一个资源，同时生产者与消费者相互依赖互为条件

  • 生产者访问仓库，往里面放；消费者也要访问，但是只拿

主要是用以下方法达到通信的效果：

  1. wait()：先释放资源，并开始等待
  2. wait(long timeout)：释放资源等待timeout秒
  3. notify()：唤醒一个处于等待状态的线程
  4. notifyAll()：唤醒同一个对象上所有调用了wait()方法的线程，优先级高的优先调度

解决方式：

  1. 管程法

    设置一个缓冲区，用于暂存数据

    代码示例：

    package cn.livorth.gaoji;

import java.util.LinkedList;
import java.util.Queue;

//管程法解决
public class TestPC {
    public static void main(String[] args) {
        //创建缓冲区
        SynContainer container = new  SynContainer();

        //双线程
        new Producer(container).start();
        new Consumer(container).start();
    }
}

//生产者
class Producer extends Thread{
    SynContainer container;

    public Producer(SynContainer container) {
        this.container = container;
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("生产了第" + i + "件产品");
            container.push(new Products(i));
        }
    }
}

//消费者
class Consumer extends Thread{
    SynContainer container;

    public Consumer(SynContainer container) {
        this.container = container;
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("消费了第" + container.pop().id + "件产品");
        }
    }
}

//产品
class Products{
    int id;

    public Products(int id) {
        this.id = id;
    }
}

//缓冲区
class SynContainer{
    Queue<Products> queue = new LinkedList<Products>();
    int count = 0;
    int size = 10;

    //生产者放入产品
    public synchronized void push(Products product)
    {
        //容器满，等待消费者消费
        if(count == size)
        {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        //没满，我们则需要存入成品,并唤醒消费者
        count++;
        queue.offer(product);
        this.notifyAll();
    }

    //消费者消费产品
    public synchronized Products pop()
    {
        //容器为空，等待生产者生产
        if (count == 0) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        //容器有剩，取出物品，并告诉生产者可以生产了
        count--;
        Products productPoll = queue.poll();
        this.notifyAll();
        return productPoll;
    }
}

  2. 信号灯法

    设置一个标记位（类似于容量为1的管程法）

    package cn.livorth.gaoji;

//信号灯法解决
public class TestPC2 {
    public static void main(String[] args) {
        //创建缓冲区
        TheProduct theProduct = new  TheProduct();

        //双线程
        new Producers(theProduct).start();
        new Consumers(theProduct).start();
    }
}

//生产者
class Producers extends Thread{
    TheProduct theProduct;

    public Producers(TheProduct theProduct) {
        this.theProduct = theProduct;
    }

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            theProduct.push("产品" + i);
        }
    }
}

//消费者
class Consumers extends Thread{
    TheProduct theProduct;

    public Consumers(TheProduct container) {
        this.theProduct = container;
    }

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            theProduct.pop();
        }
    }
}

//产品
class TheProduct{
    boolean flag = false;
    String product;
    //生产者生产，消费者等待
    public synchronized void push(String product)
    {
        if(flag)
        {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        System.out.println("生产者生产了" + product);
        this.product = product;
        this.flag = !this.flag;
        this.notifyAll();

    }

    //消费者消费，生产者等待
    public synchronized void pop()
    {
        if(!flag)
        {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        System.out.println("消费者消费了" + product);
        this.flag = !this.flag;
        this.notifyAll();
    }
}


线程池

  • 背景:经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大
  • 思路:提前创建好多个线程，放入线程池中，使用时直接获取,使用完放回池中，可以避免频繁创建销毁、实现重复利用。类似生活中的公共交通工具
  • 好处:
    • 提高响应速度(减少了创建新线程的时间)
    • 降低资源消耗(重复利用线程池中线程，不需要每次都创建)
    • 便于线程管理
      • corePoolSize:核心池的大小
      • maximumPoolSize: 最大线程数
      • keepAliveTime: 线程没有任务时最多保持多长时间后会终止

简单的使用参照Callable的使用

并发进阶以后再学

Alivorth
关注
  • 3
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
B站【狂神说Java笔记】-多线程，阿里内部爆款架构师Kafka源码笔记开源
2401_83977745的博客
04-02 557
手绘了下图所示的kafka知识大纲流程图（xmind文件不能上传，导出图片展现），但都可提供源文件给每位爱学习的朋友//账户int money;//余额//卡名//银行：模拟取款//账户//取了多少钱//现在手里有多少钱@Override//判断有没有钱System.out.println(Thread.currentThread().getName() + “钱不够，取不了”);return;try {//卡内余额 = 余额 减去 你取的前。
狂神说Java学习笔记——多线程
weixin_65098078的博客
07-19 728
狂神说Java学习笔记——多线程
【狂神说Java】Java多线程详细笔记(全)
Martin-share的博客
01-13 596
【狂神说Java】Java多线程笔记
Java多线程详解[狂神说Java]
阿正的梦工坊
03-07 849
记录知识，形成体系
Java多线程入门（狂神说）
zwt174309的博客
04-07 698
文章目录前言线程与进程线程进程线程的创建线程的三种创建方式1.继承Thread类2.实现Runnable接口3.实现Callable接口线程状态线程的五大状态获取线程状态线程常用方法停止线程线程休眠sleep（）线程的礼让yield（）线程强制执行join（）线程的优先级setPriority（int newPriority）守护线程setDeamon()线程同步对象共享问题同步方法和同步代码块同步方法同步代码块死锁死锁产生的条件Lock锁公平锁synchronized 和 Lock的区别关于多线程访问同步
多线程-狂神说Java学习笔记
07-19
狂神说Java学习笔记（笔记+源代码+图片)—多线程
Java多线程详解（超详细）_狂神说笔记完整版_项目代码_适合小白随课程学习
08-08
学习目录：1. 线程简介 2. 线程实现（重点） 3. 线程状态 4. 线程同步（重点） 5. 线程通信问题 6. 高级主题
Java多线程全部笔记（狂神说）.md
10-20
多线程通俗易懂，带案例笔记
狂神说Java笔记资料
04-14
狂神说Java笔记PDF文档。内容包括JAVA入门、基础语法、流程控制、方法、数组、面向对象、异常机制、常用类、集合框架、IO流、多线程、网络编程、Gui编程、注解和反射。
狂神说上课笔记未删减 Java基础到技术升级
08-09
11、JavaSE：多线程 12、JavaSE：网络编程 13、JavaSE：Gui编程 14、JavaSE：注解和反射 15、MySQL和JDBC 16、前端：Html5 17、前端：CSS3 18、前端：JavaScript、jQuery 19、JavaWeb 20、MyBatis 21、...
JavaSE回顾总结（狂神说java）.xmind
05-11
javaSE回顾总结，学习笔记，查漏补缺。 Java是一门面向对象编程语言，不仅吸收了C++语言的各种优点，还摒弃了C++里难以理解的多继承、指针等概念，因此Java语言具有功能强大和简单易用两个特征。Java语言作为静态面向对象编程语言的代表，极好地实现了面向对象理论，允许程序员以优雅的思维方式进行复杂的编程 Java具有简单性、面向对象、分布式、健壮性、安全性、平台独立与可移植性、多线程、动态性等特点 。Java可以编写桌面应用程序、Web应用程序、分布式系统和嵌入式系统应用程序等.
狂神说多线程详解.rar
05-06
狂神说多线程详解笔记
java全栈笔记
02-21
全栈练习笔记，用思维导图把各个技术点全部串联起来。
多线程
hjh3132778226的博客
04-09 953
多线程 文章目录多线程一、多线程简介1.多任务2.多线程3.程序.进程.线程4.Process与Thread5.核心概念二、线程实现1.线程创建（三种方法）1.1继承Thread类(重要)案例1.2实现Runnable接口案例龟兔赛跑:1.3实现Callable接口（了解）好处1.4Thread和Runnable对比2.静态代理实现: 结婚案例总结好处3.Lamda表达式函数式接口的定义:练习:练习2:总结:三、线程状态1.线程五大状态:2.线程方法2.1停止线程案例:测试stop2.2线程休眠案例:模拟网
JAVA之多线程
Stillboring的博客
10-03 227
多线程 进程是指在系统中正在运行的一个应用程序。 线程是一个进程中的执行场景/执行单元，是系统分配处理器时间资源的基本单元。 一个进程可以启动多个线程 Java进程 在运行java程序时，会先启动jvm，jvm就是一个进程，之后jvm再启动一个主线程调用main方法，同时再启动一个垃圾回收线程负责看护，回收垃圾。因此java程序中至少有两个线程并发 进程与线程的关系 进程可以看做显示生活中当中的公司 京城可以看作是公司当中的某个员工 注意java中： 进程之间内存独立不共享 线程之间，
狂神说多线程
qq_46138160的博客
02-25 440
狂神说Java多线程 1.多线程入门 1.1程序-进程-线程三者关系 运行 包含 程序------------>进程-------------->线程 静态的 1.2三种创建方式 Thread----------------->继承Thread类 Runnable-------------->实现Runnable接口 Callable---------------->实现Callable接口（目前了解） 1.3调用run（）和start（）区别 2.创建线程方式一继承Thre
多线程讲解狂神说
weixin_44502509的博客
06-16 3733
多线程讲解 学无止境,不学习就会被社会淘汰。笔记总结自狂神说多线程讲解 基本概念 进程 进程就是执行程序的一次执行过程,它是一个动态的概念,式系统资源分配的单位 通常再一个进程中可以包含若干个线程,当然一个进程中至少有一个线程,不然没有存在的意义,线程是CPU调度和执行的单位 线程 线程就是独立的执行路径 在程序运行时,即使没有自己创建线程,后台也会有多个线程,比如主线程,GC线程 main()称之为主线程,为系统的入口,用于执行整个程序 在一个进程中,如果开辟了多个线程,线程的运行是由调度器安排
Java学习笔记：多线程
11cchh的博客
02-22 945
文章目录前言多线程编程进程与线程线程创建继承Thread类实现Runnable接口实现Callable接口线程状态生命周期停止线程线程休眠线程礼让线程强制执行线程优先级守护线程线程同步初识线程并发问题锁 前言 经常在Java岗位详情中有看到"熟悉io、多线程、集合等基础框架"的要求，而自己之前在学习SE部分的时候也只是简单的过了一遍，谈不上"熟悉"二字，所以趁着空闲的时候回过头来学习。以下内容是我...
狂神说java多线程笔记
最新发布
10-11
狂神在他的Java多线程笔记中，详细介绍了Java多线程的相关知识，包括线程的创建、启动、停止、等待、唤醒等操作，以及线程安全、锁、同步等概念和技术。 在Java多线程中，线程的创建有两种方式：继承Thread类和实现...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值