Java学习记录 线程篇

最新推荐文章于 2024-08-06 09:06:55 发布
最新推荐文章于 2024-08-06 09:06:55 发布
阅读量524 收藏
点赞数
分类专栏： Java 学习记录 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45963193/article/details/114016342
版权

线程与进程

线程 是进程中的执行过程，一个进程包含有多个线程，并发执行

进程 是一个运行的应用程序，每个进程都有自己独立的内存空间。在Windows系统中，一个运行的exe（应用程序）就是一个进程

实现线程

实现线程线程主要有 java.lang.Thread类 与 Runnable接口

Thread类

Class Thread

java.lang.Object
java.lang.Thread

Thread类中实例化的对象代表线程，启动需要Thread实例

常用构造方法

Thread（）
Thread（String name）

name： 自定义线程名

常用方法

修饰符方法说明
ThreadcurrentThread()返回对当前正在执行的线程对象的引用
longgetId（）返回线程标识符
StringgetName（） 返回线程名称
intgetPriority（） 返回线程的优先级
Thread.StategetState（） 返回线程的状态
voidinterrupt（） 中断线程
booleanisAlive（） 线程是否运行
booleanisInterrupted（） 线程是否被中断
voidrun（） 调用该Runnable对象的run方法
voidstart（） 线程开始执行run方法
voidsleep（long ms） 线程以指定的毫秒数暂停（等待）
voidjoin（） 在线程中加入另一个线程
booleaninterrupted（） 中断线程
voidsetPriority（int newPriority） 设置线程的优先级newPriority的范围（1-10）
voidsetDaemon(boolean on)是否设置守护线程。守护线程：主线程结束，子线程也跟着结束
StringtoString（） 返回线程的字符串表示、线程的名、优先级、线程组

点击代码示例* （Thread操作）

Runnable接口

线程一般通过Thread类创建的。但 Runnable接口 也可以实现进程

优点

  • 适合多线程同时执行相同的任务
  • 不受 类的单继承约束

实现方式

Thread（Runnable target）
Thread（Runnable target , String name）

target： 启动线程时调用，run方法
name： 自定义线程名

点击代码示例* （Runnable操作）

Callable接口

Runnable接口 比 Callable接口 少了 线程结束无返回值 和 不能抛出异常 ，而 Callable接口 正是弥补这一缺陷！

使用步骤

//1. 编写 Callable接口 ， 实现 call抽象方法
class MyCallable implements Callable<T>{
    @Ovrride
    public <T> call() throws Exception{
        return T;
    }
}
//2. 创建FutureTask对象，并传入第一步编写的Callable类对象
FutureTask<T> future = new FutureTask<>(callable);
//3. 通过Thread，启动线程
new Thread(future).start();
//4. 获取返回值，FutureTask对象中的get()方法获取返回值（此方法有堵塞效果）
future.get();

FutureTask类 说明：用于异步获取执行结果或取消执行任务的作用（线程池的核心）

点击代码示例* （Callable操作）

线程生命周期

线程具有生命周期，有7种分别为：出生状态、就绪状态、运行状态、休眠状态、阻塞状态、死亡状态

周期的说明：

出生状态(New)： 线程创建后到线程的start（）方法前
就绪状态(Runnable)： 可执行状态，当线程获取系统资源就进入运行状态
运行状态(Running)： run（）方法，没有意外线程则一直运行到结束
休眠状态(Sleep)： 执行sleep（）方法休眠（等待）
阻塞状态(Blocked)： 等待用户 输入/输出 ，用户 输入/输出 结束后进入就绪状态
死亡状态(Dead)： 线程的run（）方法执行完毕，则进入死亡状态

Windows操作系统中，会为每个线程分配一小段CPU时间片，一旦CPU时间片结束会切换到下一线程

再次进入运行状态：

  • 线程调用notify()方法（唤醒线程）
  • 线程调用notifyAll()方法（唤醒线程）
  • 线程调用interrupt()方法（中断线程）
  • 线程的休眠时间结束
  • 输入/输出 结束

线程方法

线程休眠

sleep（long ms） 方法 停止多少秒。它可能会抛出InterruptedException异常，所以放在try-catch块中。暂停后醒来，不能保证它能立即运行！

//休眠1s
Thread.sleep(1000);

线程加入

join（） 方法 加入线程。当一个线程执行中，join()方法可使另一个线程加入，线程需要等另一个线程执行完才可以继续执行原旧的线程！
join（long millis , int nanos）

millis： 等待另一个线程的时间（秒
nanos： 另一个线程的死亡时间（纳秒

//加入ThreadB线程
··· run(){  //线程执行中
    while(true){
        //加入另一个线程
        ThreadB.join();
    }
}

线程中断

interrupted（） 方法 中断线程。 能使线程离开run()方法，同时结束线程，但会抛出InterruptedException异常！

//终止线程：ThreadA
ThreadA.interrupted();

唤醒线程

notify()
 唤醒正在等待的单个线程
notifyAll()
 唤醒正在等待的所有线程
wait() 导致当前线程等待，直到另一个线程调用该对象的 notify()方法或 notifyAll()方法

wait/notify方法的调用必须处在该对象的锁中，在调用这些方法时首先需要获得该对象的锁，需要配合同步使用，以防多线程错乱

线程礼让

yield（） 方法 线程礼让，给当前运行状态的线程提个醒，告知它可以将资源礼让给其他线程。但目前情况没有机制能保证当前线程会礼让将资源分配！（操作系统会自动分配CPU时间片执行 （不常用

线程优先级

每个线程都有自己的优先级，线程的优先级代表着该线程的重要性。多个处于就绪的线程就能体现优先级的作用！

Thread类中包含成员变量代表有：
Thread.MAX_PRIORITY = 10 （常量10
Thread.MIN_PRIORITY = 1 （常量1
Thread.NORM_PRIORITY = 5 （默认5

setPriority（int newPriority） 方法 进程优先级调整。调整线程的优先级的情况newPriority范围（0-10）

点击代码示例* （线程优先级）

线程同步

多线程执行程序，会出现线程抢资源的现象，该现象会导致数据脏读！为了防止多线程的冲突，JAVA提供了线程同步的机制来防止资源抢占的问题！

synchronized关键字

synchronized关键字采用定时只允许一个线程访问共享资源 （道理跟上排队上厕所一样

同步块

每个对象都有标志位，它具有0和1两个值。0代表同步块中在运行其他线程；1代表该线程能被同步块执行，执行中途并将Object对象的标志位设置为0，防止其他线程执行同步块中的代码。（一个线程运行到同步块时首先检查该对象的标志位）

synchronized(Object){
    ···
}
//Object：任意对象，仅作为标志（相当于一把锁，多人使用的锁）

点击代码示例* （synchronized安全线程）

同步方法

在自定义方法 前面修饰 synchronized关键字 形成同步方法。
某对象调用同步方法时，该对象的其他同步方法必须等待该同步方法执行完毕后才能被执行。必须将每个能访问共享资源的方法修饰为synchronized，否则会报错！

点击代码示例* （synchronized方法安全线程）

显示锁

Class ReentrantLock
java.lang.Object
java.util.concurrent.locks.ReentrantLock

实现接口
Serializable ， Lock

ReentrantLock 和 synchronized 又 称隐式锁 或 显示锁，它们在使用上没有什么区别 ，但ReentrantLock 可更直观的体现锁的概念。 synchronized 则是隐式实现锁的概念。

构造方法
ReentrantLock()
ReentrantLock(boolean fair)

fair： 公平锁

方法

返回方法说明
intgetHoldCount()查询当前线程对锁的停止数量
intgetQueueLength()获取锁的线程数 估数
intgetWaitQueueLength(Condition condition)获取与此锁相关条件等待的线程
booleanhasQueuedThread(Thread thread)查询指定线程是否获取锁
booleanhasQueuedThreads()查询是否有线程等待锁
booleanhasWaiters(Condition condition)查询是否有相关条件等待的锁
booleanisFair()是否为锁的公平，启动则true
booleanisHeldByCurrentThread()查询锁是否是当前线程持有
booleanisLocked()查询锁是否有线程持有
voidlock()锁定锁（上锁）
voidlockInterruptibly()锁定锁
StringtoString()返回标识锁的字符串内容
booleantryLock()
booleantryLock(long timeout, TimeUnit unit)指定时间范围，
voidunlock()释放锁（解锁）

点击代码示例* （ReentrantLock安全线程）

线程池

ExecutorService接口

继承接口
Executor

实现类
AbstractExecutorService ， ForkJoinPool ， ScheduledThreadPoolExecutor ， ThreadPoolExecutor

线程的集合称为线程池

频繁多线程操作会影响效率。反复的 创建 、关闭 线程会需要大量时间！可减少时间 和 资源的浪费！

线程池原理图

缓存线程池

  • 无长度限制
  • 自动扩容空间

点击代码示例* （缓存线程池）

定长线程池

  • 自定 固定 长度
  • 无闲线程 空间未满 自动扩容
  • 无闲线程 空间已满 等待空闲

点击代码示例* （定长线程池）

单线程线程池

  • 只有一个线程
  • 无闲线程 等待

点击代码示例* （单线程线程池）

周期性任务定长线程池

  • 可指定长度
  • 无闲线程 空间未满 自动扩容
  • 无闲线程 空间已满 等待空闲
  • 定时执行、周期执行

点击代码示例* （周期性任务定长线程池）

代码索引

File操作

（返回*）

public class Demo {
    public static void main(String[] args) {
        
        //实例对象
        Thread a = new MyThreadA();
        Thread b = new MyThreadB();
        
        /**其他方法测试*/
        System.out.println("==========");
        System.out.println("a.getId()："+a.getId());
        System.out.println("a.getName()："+a.getName());
        System.out.println("a.getPriority()："+a.getPriority());
        System.out.println("a.getState()："+a.getState());
        System.out.println("a.isAlive()："+a.isAlive());
        System.out.println("a.isInterrupted()："+a.isInterrupted());
        System.out.println("a.toString()："+a.toString());
        System.out.println("==========");
        
        //执行线程（双线程执行，同时执行）
        /**线程A*/
        a.start();
        /**线程B*/
        b.start();
        
        /**
         
        以下代码为运行a对象的run()方法再执行b对象run()方法
        a.run();
        b.run();
        
        */
        
    }
}

class MyThreadA extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 26; i++) {
            System.out.print("A："+i);
            /**休眠1秒（等待）*/
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    
}

class MyThreadB extends Thread{
    @Override
    public void run() {
        for (char i = 'a'; i < 'z'; i++) {
            System.out.println("B："+i);
            /**休眠1秒（等待）*/
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    
}



/**运行结果

==========
a.getId()：13
a.getName()：No.1
a.getPriority()：5
a.getState()：NEW
a.isAlive()：false
a.isInterrupted()：false
a.toString()：Thread[No.1,5,main]
==========
 B：a
 A：0
 B：b
 A：1
 B：c
 A：2
 A：3
 B：d
 B：e
 A：4
 A：5
 B：f
 A：6
 B：g
 A：7
 B：h
 A：8
 B：i
 B：j
 A：9
 A：10
 B：k
 A：11
 B：l
 A：12
 B：m
 B：n
 A：13
 A：14
 B：o
 B：p
 A：15
 B：q
 A：16
 B：r
 A：17
 B：s
 A：18
 A：19
 B：t
 B：u
 A：20
 A：21
 B：v
 A：22
 B：w
 B：x
 A：23
 B：y
 A：24
 A：25
 
 */

Runnable操作

（返回*）

public class MainStartRunnable {
    public static void main(String[] args) {
        Thread t = new Thread(new MyRunnable() , "A");
        Thread t2 = new Thread(new MyRunnable() , "B");
        Thread t3 = new Thread(new MyRunnable() , "C");
        
        t.start();
        t2.start();
        t3.start();
        
    }
} 
class MyRunnable implements Runnable {
    @Override
    public void run() {
        for (int i = 0 ; i < 10 ; i++) {
            System.out.println(Thread.currentThread().getName()+" : "+i);
        }
    }
}

/*

B : 0
A : 0
A : 1
A : 2
A : 3
A : 4
A : 5
A : 6
A : 7
A : 8
A : 9
B : 1
B : 2
B : 3
B : 4
B : 5
B : 6
B : 7
B : 8
B : 9
C : 0
C : 1
C : 2
C : 3
C : 4
C : 5
C : 6
C : 7
C : 8
C : 9


*/

Callable操作

（返回*）

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class Demo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        MyCallable callable = new MyCallable();
        FutureTask<Integer> future = new FutureTask<>(callable);
        new Thread(future).start();
        System.out.println("线程返回 : "+future.get());
        System.out.println("堵塞测试！！！");
    }
    
    static class MyCallable implements Callable<Integer>{
        int num = 0;
        
        //返回的方法
        @Override
        public Integer call() throws Exception {
            for (int i = 1 ; i <= 100 ; i++) {
                num += i;
                System.out.println(Thread.currentThread().getName()+" : "+i);
            }
            return num;
        }
        
    }
}

/*

Thread-0 : 1
Thread-0 : 2
Thread-0 : 3
····
Thread-0 : 100
线程返回 : 5050

*/

synchronized安全线程

（返回*）

public class Demo {
    
    public static void main(String[] args) {
        Runnable t = new Ticket();
        new Thread(t).start();
        new Thread(t).start();
        new Thread(t).start();
    }
    
    static class Ticket implements Runnable{
    
        private int count = 10;
        private final Object o = new Object();
        
        @Override
        public void run() {
            while (true){
                synchronized (o){
                    if (count > 0){
                        
                        //如果synchronized套在这里 ， 多线程会错读
                        
                        System.out.println(Thread.currentThread().getName()+" : "+ --count);
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }else {
                        break;
                    }
                }
            }
        }
        
    }
}

/*

Thread-2 : 9
Thread-2 : 8
Thread-2 : 7
Thread-0 : 6
Thread-1 : 5
Thread-0 : 4
Thread-2 : 3
Thread-0 : 2
Thread-1 : 1
Thread-0 : 0
堵塞测试！！！

 */

synchronized方法安全线程

（返回*）

public class Demo2 {
    public static void main(String[] args) {
        Runnable t = new Ticket();
        new Thread(t).start();
        new Thread(t).start();
        new Thread(t).start();
        new Thread(t).start();
    }
    
    static class Ticket implements Runnable{
        int count = 10;
        @Override
        public void run() {
            while (true){
                if (sell()){
                    break;
                }
            }
        }
    
        private synchronized boolean sell() {
            if (count > 0){
                System.out.println(Thread.currentThread().getName()+" : "+ --count);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                return false;
            }
            return true;
        }
    }
    
}

/*

Thread-0 : 9
Thread-0 : 8
Thread-0 : 7
Thread-0 : 6
Thread-0 : 5
Thread-0 : 4
Thread-3 : 3
Thread-3 : 2
Thread-1 : 1
Thread-1 : 0

* */

ReentrantLock安全线程

（返回*）

import java.util.concurrent.locks.ReentrantLock;

public class Demo3 {
    public static void main(String[] args) {
        Runnable lockTest = new LockTest();
        new Thread(lockTest).start();
        new Thread(lockTest).start();
        new Thread(lockTest).start();
        new Thread(lockTest).start();
    }
    
    static class LockTest implements Runnable{
    
        //显式锁
         static ReentrantLock l = new ReentrantLock(true);
        
        int count = 10;
        
        @Override
        public void run() {
            while (true){
                    l.lock();
                    if (sell()){
                        break;
                    }
                    if (count == 5){
                        test();
                    }
                l.unlock();
            }
            l.unlock();
            System.out.println("结束 ： "+l.tryLock());
        }
    
        private void test() {
            System.out.println(l.toString());
            System.out.println(l.getHoldCount());
            System.out.println(l.getQueueLength());
        }
    
        private boolean sell() {
            if (count > 0){
                System.out.println(Thread.currentThread().getName()+" : "+ --count);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                return false;
            }
            return true;
        }
        
    }
}

/*

Thread-0 : 9
Thread-3 : 8
Thread-2 : 7
Thread-1 : 6
Thread-0 : 5
java.util.concurrent.locks.ReentrantLock@47ee0a89[Locked by thread Thread-0]
1
3
Thread-3 : 4
Thread-2 : 3
Thread-1 : 2
Thread-0 : 1
Thread-3 : 0
结束 ： true
结束 ： false

*/

线程优先级

（返回*）

import javax.swing.*;
import java.awt.*;

public class PriorityBookTest extends JFrame {

    private Container c = getContentPane();
    private JProgressBar
            jp1 = new JProgressBar(),
            jp2 = new JProgressBar(),
            jp3 = new JProgressBar(),
            jp4 = new JProgressBar();
    private Thread
            threadA = null,
            threadB = null,
            threadC = null,
            threadD = null;

    public PriorityBookTest(){
        super("线程优先级");
        setBounds(300 , 230 ,100,150);
        setLayout(new FlowLayout());
        setVisible(true);

        threadA = new Thread(newThread(c , jp1));
        threadB = new Thread(newThread(c , jp2));
        threadC = new Thread(newThread(c , jp3));
        threadD = new Thread(newThread(c , jp4));
        setPriority("A" , 10 , threadA);
        setPriority("B" , 7 , threadB);
        setPriority("C" , 4 , threadC);
        setPriority("D" , 1 , threadD);
    }

    private static Thread newThread(Container c , JProgressBar jp){
        c.add(jp);
        jp.setStringPainted(true);
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                int count = 0 ;
                while (count <= 100){
                    jp.setValue(count++);
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
        return thread;
    }

    public static void setPriority(String threadName , int priority , Thread t){
        //设置进程优先级、名，启动
        t.setPriority(priority);
        t.setName(threadName);
        t.start();
    }

    public static void main(String[] args) {
        new PriorityBookTest();
    }
}

/*

执行结果 ： 窗体展示 进度条

*/

缓存线程池

（返回*）

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

//缓存线程池

public class Demo1 {
    public static void main(String[] args) {
        ExecutorService service = Executors.newCachedThreadPool();
        
        //执行任务
        service.execute(new Runnable() {
            @Override
            public void run() {
                 System.out.println(Thread.currentThread().getName()+" : 1");
            }
        });
    
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+" : 2");
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
    
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+" : 3");
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
    
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+" : 4");
            }
        });
        
    }
}

/*

pool-1-thread-3 : 3
pool-1-thread-2 : 2
pool-1-thread-1 : 1
pool-1-thread-1 : 4

*/

定长线程池

（返回*）

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

//定长线程池

public class Demo2 {
    
    public static void main(String[] args) {
        ExecutorService exception = Executors.newFixedThreadPool(2);
        
        exception.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+" : 1");
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
    
        exception.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+" : 2");
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
    
        exception.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+" : 3");
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
    
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    
        exception.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+" : 4");
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
    
    }
}

/*

pool-1-thread-1 : 1
pool-1-thread-2 : 2
pool-1-thread-2 : 3
pool-1-thread-1 : 4

*/

单线程线程池

（返回*）

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

//单线程线程池

public class Demo3 {
    public static void main(String[] args) {
        ExecutorService service = Executors.newSingleThreadExecutor();
        
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+" : 1");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
    
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+" : 2");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
    
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+" : 3");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        
    }
}

/*

pool-1-thread-1 : 1
pool-1-thread-1 : 2
pool-1-thread-1 : 3

*/

周期性任务定长线程池

（返回*）

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

//周期性任务定长线程池

public class Demo4 {
    public static void main(String[] args) {
        ScheduledExecutorService service = Executors.newScheduledThreadPool(2);
    
        /**定时执行
         * 参数1. 线程
         * 参数2. 延时时长值
         * 参数3. 时长单位
         */
        service.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("延时2s ， 执行的程序");
            }
        } , 2 , TimeUnit.SECONDS);
    
        /**周期执行
         * 参数1. 线程
         * 参数2. 延时时长值
         * 参数3. 周期间隔时长值
         * 参数4. 时长单位
         */
        service.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                System.out.println("延时3s 执行周期间隔2s 的循环程序");
            }
        } , 3 , 2 , TimeUnit.SECONDS);
        
        
    }
}

/*

延时2s ， 执行的程序
延时3s 执行周期间隔2s 的循环程序
延时3s 执行周期间隔2s 的循环程序
延时3s 执行周期间隔2s 的循环程序
·····

*/
柏竹
关注
专栏目录
java多线程的记录总结
qq_32844875的博客
05-15 393
线程的各种方法1.sleep():--睡眠--线程进入睡眠状态，不会释放锁（对于执行sleep方法的线程来说！）。2.yield():--释放--线程释放当前cpu，回到就绪状态，此时该线程和其他线程会同时来竞争cpu。这个方法不能保证，该线程释放后不再占有cpu，只是尽可能的让资源不要一直被该线程持续占用。3.wait():--等待--：进入线程等待池，进入挂起状态，释放锁。只能在同步控制方法或...
记录多线程
qq_45077532的博客
09-05 97
线程和进程的基本概念 程序： 用某种语言编写的一段指令的集合，静态代码静态对象 进程： 是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间 线程： 是进程中的一个执行路径，共享一个内存空间，线程之间可以自由切换，并发执行. 一个进程最少有一个线程 ，线程实际上是在进程基础之上的进一步划分，一个进程启动之后，里面的若干执行路径又可以划分 成若干个线程 并发与并行 &&同步与异步 并发：一个CPU同时执行...
Java多线程记录
mmmmmlj的博客
11-02 580
目录 多线程的创建 方式一：继承java.lang.thread，重写run方法，创建子类实例，调用子类start方法 认识多线程中的 start() 和 run() 方式二：实现Runnable接口，创建thread实例，将Runnable接口传入构造函数 方式三：实现Callable接口（JDK8新特性） 线程的生命周期 设置/获取线程名字 获取当前线程对象 sleep静态方法 sleep面试题 interruput终断休眠 stop终止线程 线程的调度 1.1常见的线程调度
Java学习笔记之多线程篇
qq_44765826的博客
06-19 200
Java多线程学习笔记 Java并发编程 Thread/Runnable/Thread线程组管理 Executor框架 Fork-Join框架 三种并发编程方式比较 线程组ThreadGroup: 线程的集合； 树形结构，大线程组可以包括小线程组； 可以通过enumerate方法遍历组内的线程，执行操作； 能有效管理多个线程，但是管理效率低 ； 任务分配和执行过程高度耦合； 重复创建线程、关闭线程操作，无法重用线程； Executor框架: 分离任务的创建和执行者的创建； 线程重复利用； 共享
Java学习路线总结，搬砖工逆袭Java架构师
热门推荐
学Java，找哪吒
09-07 25万+
定期分享Java硬核技术干货、分享Java学习路线、分享Java经典面试题
Java学习笔记
Piglett的博客
12-30 1170
随着后续的学习还会不断地更新，并不仅仅包含Java基础，后续还会更新SSM，MySQL等内容。其记录了Java基础的学习内容，主要包括24集合到30动态代理（见语雀目录）。希望这篇笔记能够帮助到Java的学习，方便快速进行回顾复习。
Java零基础之多线程篇：线程同步
最新发布
喵手的博客
08-06 794
在上几期中，我们学习了多线程的创建、生命周期及如何控制线程，而此期我们要来学习一下如何进行线程同步。我们都知道，在并发编程中，多线程的使用已经成为一种常见的解决方案。然而，当多个线程同时访问共享资源时，可能会导致数据不一致的问题。为了解决这个问题，我们需要使用线程同步机制来确保多个线程能够有序地访问和修改共享资源。本文将介绍Java中的线程同步机制。我们将使用关键字来保证同一时间只有一个线程能够执行特定的代码块或方法。我们还将讨论线程同步的应用场景、优缺点以及提供具体的Java代码测试用例来说明其效果。
Java学习笔记（多线程）：基础
sinat_38393872的博客
05-24 1233
本文主要讲解Java的线程基础，比如线程的创建方式
Java八股文之多线程篇
2201_75341115的博客
02-13 1310
进程是正在运行的程序实例，进程中包括了线程，每个线程执行不同的任务。线程和进程类似，是一个比进程更小的执行单位。不同的进程使用不同的内存空间，在当前进程下所有线程可以共享内存空间。线程更轻量，他的上下文切换成本比进程更小，所以我们也可以将其称为轻量级进程。（上下文切换指的是从一个线程切换为另一个线程）我们可以举例说明：在Java中，当我们启动main函数其实就是启动了一个JVM进程，而main函数所在的线程就是这个进程中的一个线程，也称主线程。
Java修仙之路，十万字吐血整理全网最完整Java学习笔记（高级篇）
vincewm的博客
07-18 5721
本文是“Java学习路线”中Java基础知识的高级篇，主要对多线程和反射进行了深入浅出的介绍，在多线程部分，详细介绍了线程的概念、生命周期、多线程的线程安全、线程通信、线程同步，并对synchronized和Lock锁；反射部分对反射的特性、功能、优缺点、适用场景等进行了介绍。
JAVA 多线程学习笔记
03-27
这篇学习笔记将深入探讨Java多线程的核心概念、实现方式以及相关工具的使用。 一、多线程基础 1. 线程与进程：在操作系统中，进程是资源分配的基本单位，而线程是程序执行的基本单位。每个进程至少有一个主线程，...
java虚拟机学习笔记进阶篇
08-25
本篇文章将深入探讨Java虚拟机中的垃圾收集器（GC）及其对内存管理的影响。 1. 垃圾收集器的由来与作用 垃圾收集器的引入主要是为了解决内存管理的问题。在没有GC的情况下，程序员需要手动释放不再使用的对象，这...
java多线程学习笔记之自定义线程池
08-29
本篇文章主要介绍了Java多线程学习笔记之自定义线程池，通过深入了解ThreadPoolExecutor这个核心类，我们可以自定义线程池，满足不同的线程池需求。 Java多线程学习笔记之自定义线程池的重要性在于，它可以根据不同...
java多线程学习笔记
03-01
这篇文档和对应的源代码 博文链接：https://interper56-sohu-com.iteye.com/blog/172303
Spring Cloud学习记录 08Spring Cloud Bus服务总线
柏竹的博客
11-05 1434
Bus 服务总线 Spring Cloud Bus 是轻量的消息代理，将分布式节点连接，用于广播配置文件的更新 或 监控管理 补充说明&优点 Bus 是轻量级消息代理 Bus 主要实现 配置的自动更新 （无需配置） Bus 底层基于 RabbitMQ实现 广播配置文件、监控管理 存在问题 上篇文章的 Config配置中心 启动后，此时更改 远端仓库 中某一微服务的配置文件，是不会同步本地缓存中的配置文件。因此在某一微服务运行后是不会及时更新配置文件，而是需要重启微服务才能更新生效 问题示例
Java学习记录 IDEA搭建Maven项目&Tomcat应用
柏竹的博客
06-12 1423
IDEA应用Maven项目 IDEA配置 打开所有设置（必须在这里打开设置，否则其他项目无效） 设置Maven项目目录 运行环境 Java项目的创建 有骨架 创建项目，选择骨架 配置项目基本信息 确认信息 无骨架 只需关闭选中，其他步骤跟有骨架的一致 无骨架创建项目需要自行配置 pom.xml 手动将Maven文件夹补齐 JavaWeb项目的创建 有骨架 步骤就一步不一样，其他剩下步骤就不赘述了！ 无骨架 无骨架创建项目后，需要自行配置 JavaWeb信息 项目配置 手动
Java学习记录 Maven常用命令
柏竹的博客
06-12 1282
Maven常用命令 Maven命令需要在 pom.xml 所在目录中执行 mvn compile 生成 target目录,该目录中存放了编译后的字节码文件 mvn clean 删除 target目录 mvn test 在 target目录 中生成，surefire、 surefire-reports（测试报告）、test-classes（测试的字节码文件）三个文件夹 mvn package 在 target目录 中生成本项目的 jar包 或 war包 等 mvn install 将打包好的 jar包
Java学习记录 MyBatis框架应用
柏竹的博客
07-31 736
文章目录Mybatis框架Mybatis对象ResourcesSqlSessionFactoryBuilderSqlSessionFactorySqlSessioMyBatis构架配置日志Mapper动态代理输入映射传递多个参数#{} 和 ${} 区别输出映射MyBatis全局配置文件配置内容propertiessettingstypeAliasesMappersMyBatis映射关系对一 映射关系对多映射关系动态SQLMyBatis缓存一级缓存二级缓存二级缓存其他设置MyBatis逆向生成 参考文档：my
JAVA学习笔记：入门篇
"Java学习笔记初步概述" 在Java学习的初期，我们首先会接触到的是Java程序的两种核心运行机制。Java程序的执行依赖于Java虚拟机（JVM），它负责将编译后的字节码文件转化为机器语言，使得Java代码能在不同的操作...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值