如何应对Android面试官->线程与进程、手写ThreadLocal

Java ThreadLocal内存泄漏原理、排查与最佳实践 在Java多线程编程中,线程局部变量(ThreadLocal)是实现数据隔离和无锁线程安全的重要机制。其核心原理是为每个线程维护一个独立的变量副本,通过ThreadLocalMap存储,其中Entry的Key采用弱引用指向ThreadLocal实例。这一设计虽然实现了数据隔离,但也带来了潜在的内存泄漏风险:当线程池复用线程时,若未及时清理,强引用的Value会随线程长期存活而无法回收,形成内存泄漏。从技术价值看,ThreadLocal广泛应用于Spring事务管理、用户会话信息存储等场景,如Spring B 阅读详情

基础概念

什么是进程和线程?

进程:一个正在运行的应用程序;操作系统管理的最小单元(操作系统进行资源分配的最小单位),一个进程至少一个线程,或者多个线程;进程与进程之间是相互独立的;

资源:运行一个程序需要 CPU、内存空间,磁盘IO,这些都属于运行一个程序所需要的资源;

线程:进程的运行方法;CPU 调度的最小单元,如果一个进程还有一个线程没有杀掉,那么进程就还是处于存活状态(线程依附与进程而存在);线程之间是可以共享资源的,包括CPU、内存空间,磁盘IO;

CPU核心数和线程数的关系?

早期一个核心一个线程,后期超线程技术之后 一个核心两个线程;

什么是多核?早期的计算机芯片上面只能放一个逻辑核心,随着摩尔定律的失效,大家发现在CPU上在缩短这个宽度3纳米,在往小缩短就要受到量子物理的约束,此时提高晶体管的密度是不可行的了;那么把多个物理核心集成到一块芯片上,也就是说在一块物理芯片上会有多块处理器,这就是所谓的CPU多核;

为什么CPU的核心数限制,但是我们在启动一个应用程序之后 启动了很多线程(超过了线程数)但是我们的程序还是能正常执行?

CPU时间片轮转机制?

CPU 运行过程中分时间的机制;

CPU 调度,会把 1秒钟 分成好多小的单位,假设每个单位都是 1 纳秒,所有线程都会去操作系统抢占这个 1纳秒,谁抢到了谁就去执行,假设有三个线程 A B C,A 抢到了这一纳秒的时间,那么就去运行 A 线程的代码,当运行到A线程的某个代码位置的时候,这 1纳秒 用完了,就要释放 CPU 出来,然后和其他线程继续去抢第二个 1纳秒,假如第二个时间片被其他线程抢到了,就执行其他线程,依次往后所有线程继续抢,当 A 再次抢到的时候,要接着 A 执行到的地方继续执行,谁来记录 A 执行到了什么地方,就由程序计数器来负责;

并发、并行?

并行:同时有多个线程在执行,可以同时运行的任务数;

并发:既有前台 又有后台,交替执行;总结的同一个时间点的吞吐量(讨论并发的时候不能脱离时间单位,否则没有意义);

举例子:假设咖啡机在 1分钟 之内,有四个人拿到了咖啡,那么咖啡机在一分钟内的并发量就是 4

综合来说:并发就是说我们的应用能交替的执行不同的任务,只不过 CPU 或者操作系统使用了不同的技术,使人以不可察觉的速度在运行这些任务。看起来好像达到了同时执行的效果,但其实不是;

线程存在并行和并发 协程只有并发没有并行;

高并发编程的意义,好处是什么?

平衡使用我们的线程,不要 CPU 过累;

Java程序默认是多线程还是单线程?

Java 程序默认是多线程的;执行一个 Java 程序,可能会有 6 个 也可能会有 8 个;

public class OnlyMain {    
    public static void main(String[] args) {        
        ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();        
        ThreadInfo[] threadInfos = threadMXBean.dumpAllThreads(false, false);        
        for (ThreadInfo threadInfo : threadInfos) {            
            System.out.println("[" + threadInfo.getThreadId() + "], " 
                + threadInfo.getThreadName());        
        }    
    }
}

多次执行,会开启 6 - 8 个线程;

为什么要用线程池来管理线程,是否可以无限制的创建线程?

Linux 下一个进程所能开的线程数最多 1000 个;Windows 下一个进程所能开的线程数最多 2000个;

那么线程创建会分配栈空间,缺省是 1MB,只单纯的 new 1000 个线程,所占用的内存就达到了 1G;

资源回收的动作放在 finalize 方法中为什么会不靠谱? 

因为很有可能不会被执行,因为执行这个方法是一个单独的 Finalizer 线程,这个线程是守护线程,当主线程一旦退出,这个线程就跟着退出了,那么这个方法很有可能来不及调用,这个线程就结束了,相关的资源释放工作还没做完;

Thread

线程实现有几种方式?

两种方式,一是 extends Thread,一是 implements Runnable,实现 Callable 接口严格意义上来说不是

源码中的注释 【There are two ways to create a new thread of execution】说明只有两种方式来创建线程;

继承 Thread 类

class PrimeThread extends Thread {        
    long minPrime;        
    PrimeThread(long minPrime) {             
        this.minPrime = minPrime;         
    }         
    public void run() {             
                
    }     
}


PrimeThread pThread = new PrimeThread(1000L);
pThread.start();

实现 Runnable 接口

class PrimeRun implements Runnable {         
    long minPrime;         
    PrimeRun(long minPrime) {             
        this.minPrime = minPrime;         
    }         
    public void run() {             
            
    }     
}


PrimeRun pRun = new PrimeRun(1000L);
Thread thread = new Thread(pRun);
thread.start();

实现 Callable 接口 本质上还是实现了 Runnable 接口,所以它其实可以和 Runnable 归位一类

public class ThreadCallable implements Callable<String> {    
    @Override    
    public String call() throws Exception {        
        return null;    
    }
}
public static void main(String[] args) {    
    ThreadCallable threadCallable = new ThreadCallable();    
    FutureTask<String> futureTask = new FutureTask<>(threadCallable);    
    new Thread(futureTask).start();
}

本质上:Callable 的实例会交给 FutureTask,而 FutureTask 实现了 RunnableFuture 接口,而 RunnableFuture 接口继承自 Runnable 接口;

所以:实现线程的方式只有两种

继承 Thread 和  实现 Runnable 的区别 ?

Thread 是对线程的抽象,Runnable 是对任务(业务逻辑)的抽象;

线程的安全终止

Thread 源码中有一个 stop 方法,但是这个 stop 方法被 JDK 打上了一个废弃的注解 @Deprecated

Thread 源码中还有一个 destory 方法,但是这个 destory 方法被 JDK 打上了一个废弃的注解 @Deprecated

Thread 源码中有一个 suspend 方法,但是这个 suspend 方法被 JDK 打上了一个废弃的注解@Deprecated 

JDK并不建议使用这几个方法,这些方法带有很高的强制性;例如 suspend 方法,会让线程发生一次上下文切换,从当前的一个可运行状态切换到一个挂起状态,但是 suspend 被调用后,相关的线程并不会释放锁,而是占着这个资源进入一个睡眠状态,这样就很容易发生死锁的问题;同样的 stop 在终结一个线程的时候,比较野蛮会强制把当前线程一把干掉,不关心当前线程有没有释放资源;

例如:开启一个线程,写一个10K的文件,当写到4K的时候,调用了 stop,那么这个线程就会被野蛮停掉,那么这个文件就是缺省的,不能被使用的;

所以说 stop、suspend、destory等 为什么不建议使用?因为它可能导致线程所占用的资源不会释放;

Thread 中提供了比较和谐的方式,thread.interrupt() 发起停止信号,和 isInterrupted() 接收停止信号结合使用;

Thread 源码中,有 4 个关于 interrupt 的方法

interrupt 对线程进行终断,但并不是真真正正的终止一个线程,而是发给线程的一个终断标志位,当调用这个方法的时候,其实就是给线程打了一个招呼,不代表这个线程就要立即停止工作,而且这个线程完全可以不理会这个终断请求(也就是说 JDK 中,线程是协作式的,而不是所谓的抢占式);

isInterrupted 判断当前线程是否被终断;

public static class UseThread extends  Thread {        
    public UseThread(String name) {        
        super(name);    
    } 
   
    @Override    
    public void run() {        
        super.run();        
        String threadName = Thread.currentThread().getName();        
        System.out.println(threadName + " interrupt flag = " + isInterrupted());        
        while (!isInterrupted()) { 
        // while (true) {  
        // while (Thread.interrupted())        
            System.out.println("thread is running");            
            System.out.println(threadName + " inner interrupt flag = " + isInterrupted());        
        }        
        System.out.println(threadName + " interrupt flag = " + isInterrupted());    
    }
}


public static void main(String[] args) throws InterruptedException {        
    UseThread useThread = new UseThread("endThread");        
    useThread.start();        
    Thread.sleep(10);        
    useThread.interrupt(); // 终断线程,设置一个标志位为 true  
}

当调用了 interrupt 的时候,如果不用 isInterrupted 接收的话,也就是 while(true) 放开,那么线程还是会一直执行

interrupted  这个方法是 Thread 的一个静态方法,判断当前线程是否被终断,与 isInterrupted 在使用上有区别,区别如下:

Thread.interrupted 会将是否终断的标志位清除,如果设置成了 true,那么它就会重置回 false

那么,在 Runnable 中 如何终断线程呢?

通过 Thread.currentThread().isInterrupted();

public class ThreadRunnable implements Runnable {        
    @Override    
    public void run() {        
        String threadName = Thread.currentThread().getName();        
        System.out.println(threadName + " interrupt flag = " + Thread.currentThread().isInterrupted());        
        while (!Thread.currentThread().isInterrupted()) {            
            System.out.println("thread is running");            
            System.out.println(threadName + " interrupt flag = " + Thread.currentThread().isInterrupted());        
        }        
        System.out.println(threadName + " interrupt flag = " + Thread.currentThread().isInterrupted());    
    }
}

Thread.sleep() 方法 会抛出一个 InterruptedException,那么当我们 catch 住这个异常之后,获取当前终断标志位的时候 是 true 还是 false ?

public static class HasInterruptException extends Thread {    
    @Override    
    public void run() {        
        super.run();        
        while (!isInterrupted()) {            
            try {                
                Thread.sleep(100);            
            } catch (InterruptedException e) {                
                System.out.println(Thread.currentThread().getName() + "in InterruptedException interrupt flag is " + isInterrupted());                
                e.printStackTrace();            
            }            
            System.out.println(Thread.currentThread().getName() + "I am extends Thread");        
        }        
        System.out.println(Thread.currentThread().getName() + " interrupt flag is" + isInterrupted());    
    }
}

结果是 false ,也就是说线程抛出这个异常的同时,把标志位又重置成了 false;

所以 需要我们在 catch 的时候,手动的调用一下 interrupt() 方法;

public static class HasInterruptException extends Thread {    
    @Override    
    public void run() {        
        super.run();        
        while (!isInterrupted()) {            
            try {                
                Thread.sleep(100);            
            } catch (InterruptedException e) {                
                System.out.println(Thread.currentThread().getName() + "in InterruptedException interrupt flag is " + isInterrupted());                
                interrupt();
                e.printStackTrace();            
            }            
            System.out.println(Thread.currentThread().getName() + "I am extends Thread");        
        }        
        System.out.println(Thread.currentThread().getName() + " interrupt flag is" + isInterrupted());    
    }
}

所以:JDK 针对 sleep、wait 等增加异常抛出的原因是什么?有什么好处?

修改终断标志位为 false,可以让我们及时的释放资源,并手动的调用 interrupt 来终断线程,防止死锁的发生;

run 和 start 的区别?

run 是方法,和线程没有任何关系,start 会走底层,最终调度到 run 方法;run方法一般是业务实现的方法,可以多次调用,也可以直接通过声明的 thread 对象来调用 run 方法;

如果我们直接调用 run 方法的时候 会发生了什么?

public class ThreadRun {    
    public static void main(String[] args) {        
        ThreadRunTest runTest = new ThreadRunTest();        
        runTest.run();    
    }    

    static class ThreadRunTest extends Thread {        
        @Override        
        public void run() {            
            super.run();            
            int i = 90;            
            while (i > 0) {                
                try {                    
                    Thread.sleep(1000);                
                } catch (InterruptedException e) {                    
                    e.printStackTrace();                
                }                
                System.out.println("CurrentThread: " + Thread.currentThread().getName() + ", and i = " + (i--));            
            }        
        }    
    }
}

直接调用 run 方法,当前逻辑会在主线程执行,不会在子线程执行,只有调用 start 方法才会在子线程中执行;

所以:start 才是真正意义上的启动了一个线程并和操作系统里面的线程进行一个挂钩。run 本质上就是普通类里的一个普通方法而已。对于 new 出来的一个线程 start 只能调用一次,多次调用就会抛出异常;

调用 start0 方法 真真正正的开始执行线程,调度到 native 层;

start 方法调用两次会抛出异常;通过 threadStatus != 0 的判断,会抛出 IllegalThreadStateException 异常;

线程状态(生命周期)

新建(初始):new 一个新的线程对象,就称为线程的初始,但是初始不代表这个线程就开始执行了,只有调用了 start 方法之后才会进入运行态;

运行态:

  • 就绪(可运行状态)
    1. CPU 时间片用完了或者被操作系统剥夺了或者自动放弃了,线程就会出于就绪中,等待下次的时间片;
    2. 调用 join 获得执行权,通过系统调度进入运行中;
  • 运行中
    1. 拿到了时间片,被分配了 cpu,就处于运行中;
    2. 调用 yield 就会进入就绪状态;
  • yield 方法 让当前线程让出 cpu 的执行权(仅仅只是让出 cpu 执行权,但是不会让出锁),当前线程就会由运行态进入可运行状态(就绪);
  • join 方法  让cpu放弃当前正在执行的线程,转而来执行调用 join 方法的线程;

等待态:

  • 等待
    1. 线程调用了 wait、join、sleep、LockSupport.park() 方法,进入等待态;
    2. 当线程调用了 notify 或者 notifyAll、LockSupport.unpark(Thread) 之后,线程就会重新进入运行态;
  • 等待超时
    1. 线程调用 wait(long)、sleep(long)、 join(long)、LockSupport.parkNanos()、LockSupport.parkUntil() 方法,传入时间,当到达这个时间阈值之后,就是等待超时态;
    2. 超时之后,或者当线程调用了 notify、notifyAll、LockSupport.unpark(Thread) 之后,线程就会重新进入运行态;

阻塞态:

  • 线程调用了synchronized 修饰的代码或者代码块,如果没有拿到锁,就会处于阻塞状态。只有 synchronized 修饰的才会进入阻塞状态,其他都不是,例如:调用 Lock,它底层实现就是调用了LockSupport,所以调用 lock 是进入了等待或者等待超时;
  • 获取到锁之后,线程就会重新进入运行态(属于被迫进入);

执行完成(终止)态:

  • run方法跑完了,就会进入完成态;
  • 调用了 stop 方法,强制关闭,也会进入完成态
  • 调用了 setDeamon 方法,将当前线程变成守护线程,当进程中的所有非守护线程都执行完毕之后,那么守护线程就会跟着死亡进入完成态;

如何控制线程的执行顺序?

join 关键方法,join 的意思是使得 cpu 放弃当前线程的执行,并返回对应的线程,例如 调用 A 线程的 join 方法,则主线程放弃 cpu 控制权,并返回 A 线程继续执行,直到 A 线程执行完毕,A 执行完毕释放之后主线程继续执行调用 b.start();

ThreadJoinTest a = new ThreadJoinTest("A");
ThreadJoinTest b = new ThreadJoinTest("B");

a.start();
a.join();
b.start();
// 会在 a 执行完毕之后 才执行 b,一定要注意这个调用顺序

能不能控制线程的优先级?

不会考虑,setPriority() 方法能不能发挥作用完全由操作系统来决定,因为线程的优先级很依赖于系统的平台,所以这个优先级无法对号入座,无法做到你想象中的优先级,属于不稳定,有风险;因为某些开源框架,也不可能依赖线程优先级来设置自己想要的优先级顺序,这个是不可靠的;

守护线程

先来看一组示例

上面这些除了 main(主线程) 之外都可以认为是守护线程,守护线程也包括GC;守护线程其实是一种支持类的线程,主要是对程序后台做一些调度、支持性的工作(比如内存的回收等等);

当我们启动了一个进程的时候,这个进程中会通过 new Thread 启动了很多的线程,那么这些通过 new Thread 启动的线程,如果不设置 setDameon 都是用户线程(非守护线程),对于 JDK 内部启动的线程或者通过参数配置(setDameon)启动的线程都是守护线程;

在一个进程里面,如果所有的用户线程(非守护线程)都结束之后,这个进程也就跟着停止了,那么所有的守护线程也就结束了;

public class DaemonThread {    
    public static void main(String[] args) throws InterruptedException {        
        UseThread useThread = new UseThread();        
        useThread.setDaemon(true);        
        useThread.start();        
        Thread.sleep(5);    
    }    
    static class UseThread extends Thread {        
        @Override        
        public void run() {            
            super.run();            
            try {                
                while(!isInterrupted()) {                    
                    System.out.println(Thread.currentThread().getName() + " extends Thread");                
                }            
            } finally {                
                // 守护线程的 finally 不一定起作用                
                System.out.println("finally");            
            }        
        }    
    }
}

执行之后,因为 UseThread 被设置成了守护线程,当我们的主线程执行完毕(Thread.sleep(5) 执行之后)之后,这个 UseThread 就会停止执行,不需要我们调用 useThread.interrupt();

但是,通过 Console 中的打印结果来看,finally 并没有执行;

也就是说我们不能通过 finally 代码块来确保执行关闭、清理资源;finally 能否执行完全看操作系统的调度;

用户线程不用担心,finally 一定会执行;

能不能指定 CPU 去执行某个线程?

不能。Java 做不到,唯一能够去干预的就是 C 语言调用内核 API 去指定才行;

多线程间数据如何共享(锁)

多个线程之间访问同一个对象,如果我们不做操作会发生什么?

public class SyncThread {    
    private int count = 0;    
    public void addCount() {        
        count++;    
    }    
    public static void main(String[] args) throws InterruptedException {        
        SyncThread syncThread = new SyncThread();        
        AddCount addCount1 = new AddCount(syncThread);        
        AddCount addCount2 = new AddCount(syncThread);        
        addCount1.start();        
        addCount2.start();        
        Thread.sleep(5);        
        System.out.println(syncThread.count);    
    }    
    static class AddCount extends Thread {        
        private SyncThread simpleOper;        
        public AddCount(SyncThread simpleOper) {            
            this.simpleOper = simpleOper;        
        }        
        @Override        
        public void run() {            
            super.run();            
            for (int i = 0; i < 10000; i++) {                
                simpleOper.addCount();            
            }        
        }    
    }
}

执行多次,都不是想要的结果(20000),多线程操作同一个全局变量,导致结果不正确;

还有如下示例代码:

public class GpsEngine{
    private static GpsEngine gpsEngine;
    public static GpsEngine getGpsEngine() {
	if(gpsEngine == null) {
	    // 时间片轮转机制当Thread-0执行到这里的时候,执行结束,CPU 执行器被操作系统调度器给释放了,那么 Thread-0 就会暂停到这里,当 Thread-0
	    // 再次抢到的时候,由程序计数器告知,继续执行,那么就又会执行一次对象的创建,违背了单例的初衷(一个实例)
            // 但是 Thread-1 执行到创建对象的这行代码 才执行结束,CPU 执行器被操作系统调度器释放。
	    gpsEngine = new GpsEngine(); 
	}
	return gpsEngine;
    }
}
// 上述代码线程不安全,如果多个线程同时获取GpsEngine实例,就会出问题

多线程创建单例问题,不符合了单例的一个对象原则;

如何解决?加锁!

synchronized // 内置锁。保证在某一个时刻只有一个线程访问这个变量

对象锁

synchronized 作用在方法上,把这个方法变成同步方法

public synchronized void addCount() {    
    count++;
}

synchronized 作用在代码块上,把这段代码变成同步代码块

Object object = new Object();
public void addCount1() {    
    synchronized (object) {        
        count ++;    
    }
}

这些也都可以叫作 对象锁,锁的作用是在同一个对象上;

如果锁在两个对象上,则这个就会失效;

类锁

synchronized 作用在静态方法上,会被叫作 类锁(class对象锁)

public static synchronized void addCount() {    
    count++;
}

每一个类在进行类加载的时候,都会在 JVM 中有一个 class 对象,static 方法上进行加锁的时候,意味着加锁的是一个 class 对象,本质上还是一个对象锁。这个对象就是每个类在虚拟机中所拥有的唯一的一个 class 对象;

类锁和对象锁之间也是互相不干扰的,因为不是同一个对象;

但是:

这种情况下是可以并行的,因为是两个不同的锁对象,一个是 class 对象,一个是 object 对象;

死锁

死锁是指两个或者两个以上的进程在执行过程中,由于竞争资源或者由于彼此通信而造成的一种阻塞的现象,若无外力作用,它们都将无法推进下去。此时称系统处于死锁状态或者系统产生了死锁 ;

产生死锁的原因:

  1. 多个操作者(M >=  2)争夺多个资源(N >= 2),N <= M;
  2. 争夺资源的顺序不对;
    • 解决方案:顺序争夺资源;
  3. 拿到资源不放手;
    • 解决方案:使用尝试拿锁的机制 tryLock()、资源使用完毕之后放手-> lock()  unlock();

死锁代码示例:

public class DeadLockThread {    
    private static Object obj1 = new Object();    
    private static Object obj2 = new Object();    

    public static void a() throws InterruptedException {        
        String threadName = Thread.currentThread().getName();        
        synchronized(obj1) {            
            System.out.println(threadName + " get obj1");            
            Thread.sleep(100);            
            synchronized(obj2) {                
                System.out.println(threadName + " get obj2");            
            }        
        }    
    }    

    public static void b() throws InterruptedException {        
        String threadName = Thread.currentThread().getName();        
        synchronized(obj2) {            
            System.out.println(threadName + " get obj2");            
            Thread.sleep(100);            
            synchronized(obj1) {                
                System.out.println(threadName + " get obj1");            
            }        
        }    
    }    
    
    static class Kobe extends Thread {        
        private String name;        
        public Kobe(String name) {            
            this.name = name;        
        }        
        @Override        
        public void run() {            
            Thread.currentThread().setName(name);            
            try {                
                a();            
            } catch (InterruptedException e) {                
                e.printStackTrace();            
            }        
        }    
    }    
    public static void main(String[] args) {        
        Thread.currentThread().setName("James");        
        Kobe kobe = new Kobe("Kobe");        
        kobe.start();        
        try {            
            b();        
        } catch (InterruptedException e) {            
            e.printStackTrace();        
        }    
    }
}

从打印结果来看,发生了死锁,如果没有发生死锁的话,则日志应该都能输出;程序一旦发生死锁是没有办法恢复的,只能重启程序;

解决方案代码示例:

public class TryLockThread {    
    private static Lock obj1 = new ReentrantLock();    
    private static Lock obj2 = new ReentrantLock();    
    public static void a() throws InterruptedException {        
        String threadName = Thread.currentThread().getName();        
        Random random = new Random();        
        while (true) {            
            if (obj1.tryLock()) {                
                System.out.println(threadName + " get obj1");                
                try {                    
                    if (obj2.tryLock()) {                        
                        try {                            
                            System.out.println(threadName + " get obj2");                            
                            System.out.println("a to b do work ... ");                            
                            break;                        
                        } finally {                            
                            obj2.unlock();                        
                        }                        
                    }                
                } finally {                    
                    obj1.unlock();                
                }            
            }
            // 这里休眠是为了:减少拿锁的过程,也就是减少活锁产生的时间             
            Thread.sleep(random.nextInt(3));        
        }    
    }   
 
    public static void b() throws InterruptedException {        
        String threadName = Thread.currentThread().getName();        
        Random random = new Random();        
            while (true) {            
                if (obj2.tryLock()) {                
                    System.out.println(threadName + " get obj1");                
                    try {                    
                        if (obj1.tryLock()) {                        
                            try {                            
                                System.out.println(threadName + " get obj2");                            
                                System.out.println("b to a do work ... ");                            
                                break;                        
                            } finally {                            
                                obj1.unlock();                        
                            }                    
                        }                   
                    } finally {                    
                        obj2.unlock();                
                    }            
                }
                // 这里休眠是为了:减少拿锁的过程,也就是减少活锁产生的时间            
                Thread.sleep(random.nextInt(3));        
            }    
       }    

        static class Kobe extends Thread {        
            private String name;        
            public Kobe(String name) {            
                this.name = name;        
            }        
            @Override        
            public void run() {            
                Thread.currentThread().setName(name);            
                try {                
                    a();            
                } catch (InterruptedException e) {                
                    e.printStackTrace();            
                }        
            }    
        }    
        
        public static void main(String[] args) {        
            Thread.currentThread().setName("James");        
            Kobe kobe = new Kobe("Kobe");        
            kobe.start();        
            try {                
                b();        
            } catch (InterruptedException e) {            
                e.printStackTrace();        
            }    
        }
}

没有发生死锁的问题;

显示锁

本质可以自己控制程序的锁定和解锁;

Lock 所有继承 lock 接口的锁都是显示锁;

// ReentrantLock 可重入锁: 就是在递归的时候 可以反复的拿锁;
Lock lock = new ReentrantLock(); 
lock.lock(); // 加锁
try{

}finally{
    lock.unlock(); // 解锁
}
// 这两个方法是必须要实现的

所以:可重入锁也是显示锁;

示例代码:

public class LockDemo{
    private Lock lock = ReentrantLock();
    private int count = 0;
    public void incr() {
	lock.lock();
	try {
	    count ++;
	} finally {
            lock.unlock();
	    incr();
	}
    }
}

wait、notify

notify

唤醒 wait();  被冻结的线程,如果没有冻结的线程,没有任何关系,java 默认不会报错,默认会不处理;

wait

当前自己线程冻结,释放 CPU 执行资格,让出 CPU 执行权,让 CPU 去执行其他线程;

示例代码:

public class WaitNotifyTest {
    
    static class Res {
	public int id;
	public String name;
        private boolean flag = false;
	// 生产
	public synchronized void in() {
	    if(!flag) {
		id += 1;
		System.out.println("produce: " + id);
		flag = true;
		notify();
                try {
		    wait();
		} catch (Exception e) {
		    //
		}
	    }
	}
        // 消费
	public synchronized void out() {
	    if(flag) {
		id -= 1;
		System.out.println("consumer: " + id);
		flag = false;
		notify();
                try {
		    wait();
		} catch (Exception e) {
		    //
		}
	    }
	}
    }

    class ProduceThread extends Thread {
        private Res mRes;
	public ProduceThread(Res res){
	    this.mRes = res;
	}

	@Override
	public void run() {
	    for (int i = 0; i < 20; i++) {
		mRes.in();
	    }
	}
    }

    class ConsumerThread extends Thread {
	private Res mRes;
	public ProduceThread(Res res){
	    this.mRes = res;
	}

	@Override
	public void run() {
	    for (int i = 0; i < 20; i++) {
		mRes.out();
	    }
	}
    }

    public class Test {
	public static void main(String[] args) {
	    Res res = new Res();
	    ProduceThread pt = new ProduceThread(res);
	    ConsumerThread ct = new ConsumerThread(res);
            pt.start();
            ct.start();
	}
    }
}

wait 和 notify 只有操作同一把锁的时候才生效,如何确定是同一把锁,由 main 函数中的两个 thread 操作的是同一个对象来确定 这两个线程操作的是同一个锁,那么 notify 唤醒的是操作这个对象的所有线程,wait 是当前线程哪个线程调用,哪个线程就会释放 CPU 执行权;

wait 和 notify 在使用的时候必须要被 synchronized 包裹着,否则会报错;

wait、sleep

wait 和 sleep 是都会让出 CPU 执行权的,但是 sleep 不会释放锁,wait 会释放锁;

sleep 可以在任何地方使用,而 wait 只能在同步方法或者同步块中使用;

try {
    Thread.sleep(1000); 
} catch(Exception e) {
    // 
}

从锁的状态来区分,可以有多少种锁,以及它们的优缺点?

  1. 无锁状态;
    • 不锁住资源,多个线程中只有一个线程能修改成功,其他线程会重试;
  2. 偏向锁
    • 大多数情况下,锁不仅不存在多线程竞争,而且总是由同一线程多次获得,为了让线程获取锁的代价更低,引入来偏向锁;
    • 拿锁的过程中 判断对象头中的线程 ID 是不是自己,是的话 就不进行自旋操作;
  3. 轻量级锁
    • 指的就是那些没有被挂起或者阻塞的线程通过 CAS 操作来加锁和解锁;
    • 自旋锁;
    • 适应性自旋锁;
      • 控制自旋次数的锁,在 JDK1.5 的时候 默认定义为 10次,JDK1.6 之后改为了无固定的值,由虚拟机自行判定;
      • 超过自旋时间之后,就会膨胀为重量级锁;
  4. 重量级锁
    • 没有拿到锁的线程都是要被阻塞或者挂起;

线程本地变量 ThreadLocal

线程隔离,保证线程独有的属性。ThreadLocal 可以让每个线程拥有一个属于自己的变量副本,不会和其他线程的变量副本冲突,实现了线程的数据隔离;

ThreadLocal 原理

get实现

public T get() {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null) {
        ThreadLocalMap.Entry e = map.getEntry(this);
        if (e != null) {
            @SuppressWarnings("unchecked")
            T result = (T)e.value;
            return result;
        }
    }
    return setInitialValue();
}

set实现

public void set(T value) {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null)
        map.set(this, value);
    else
        createMap(t, value);
}

ThreadLocalMap 实现

每一个 ThradLocaMap 都持有一个 Entry[]数组,数组中的每个 Entry 实例持有两个变量;

  • ThreadLocal<?> k
  • Object v

为什么是 Entry[]?

变量副本保存在线程自己的内部,每个线程又可以拥有多个ThreadLocal变量副本,为了保证线程变量副本的唯一,所以内部就用了一个数组来保存这多个 ThreadLocal 变量;

手写 ThreadLocal 核心实现

public class CustomThreadLoacl<T> {
    // 存放变量副本的map容器,以 Thread 为 key,变量副本为 value
    private Map<Thread, T> theadMap = new HashMap<Thread, T>();
    
    public syncorhized T get() {
        return theadMap.get(Thread.currentThread());
    }

    public synchroized set(T t) {
        theadMap.set(Thread.currentThread(), t);
    }
}

简历润色

简历上可写:深度理解Java多线程、线程安全、并发编程,可手写ThreadLocal的核心实现;

下一章预告

带你玩转CAS原理;

欢迎三连

来都来了,点个关注、点个赞吧~~

Android校招笔试题解析:从Handler到Binder,掌握核心机制与性能优化 在Android应用开发中,消息循环、跨进程通信和视图分发是构建稳定应用的基础。理解Handler与Looper的工作机制,掌握Binder的IPC原理,以及熟悉Activity启动流程和View事件分发,是校招笔试的高频考点。同时,内存泄漏、GC回收、线程池并发和Bitmap图片加载等性能优化问题,直接体现了工程师的工程实践能力。本文围绕一套Android校招笔试题,梳理其背后的知识体系与答题思路,帮助读者从原理层面系统复习,并应对实际开发中的复杂场景。 阅读详情

相关推荐

Android高级工程师面试核心考点与实战解析

在Android开发领域,系统架构设计与性能优化是衡量工程师能力的关键维度。从技术原理层面,Handler机制通过消息队列实现线程通信,其底层采用单链表结构保证高效操作;Binder作为Android特有的IPC机制,利用mmap内存映射实现高效跨进程数据传输。这些核心技术支撑着应用启动优化、内存管理等工程实践,尤其在短视频、电商等高并发场景中至关重要。大厂面试常聚焦组件化架构、Jetpack组件等现代开发范式,考察候选人解决复杂问题的能力。本文基于字节跳动、腾讯等企业的真实面试案例,深度剖析线程通信、Ko

cmff98425的博客 417

线程占用内存多大?

#include #include int main() { // char *p =(char *) malloc(1024*1024); while(1) { sleep(1); } return 0; }主线程main占用内存大小为4188K ,大约4M 示例2: #

why is this 1万+

Android面试备战:JVM与Handler机制深度解析

在Android开发中,JVM内存模型和Handler机制是面试中的高频考点。JVM作为Java程序的运行环境,其内存分配、垃圾回收机制直接影响应用性能;而Handler作为Android线程间通信的核心组件,涉及消息队列、Looper等关键概念。理解这些底层原理不仅能优化应用性能,还能有效避免内存泄漏等问题。实际工程中,Handler机制广泛应用于UI更新、任务调度等场景,而JVM调优则是解决OOM、卡顿等问题的关键。本文通过Handler内存泄漏案例和JVM内存分析工具的使用,帮助开发者系统掌握这些核心

aiqixiao2017的博客 447

深入剖析ThreadLocal内存泄漏:从原理到Spring Boot实战解决方案

在Java多线程编程中,线程局部变量是解决线程间数据隔离的核心机制。其原理是通过为每个线程创建独立的变量副本,从而避免共享冲突,提升并发性能。这一机制在数据库连接管理、用户会话上下文传递等场景中具有重要技术价值。然而,若使用不当,特别是在结合线程池等长生命周期线程的应用场景中,容易引发内存泄漏问题。本文聚焦于ThreadLocal的内存泄漏根源,结合Spring Boot框架中的典型应用,分析弱引用与强引用交织下的泄漏链,并提供通过拦截器统一清理等工程级解决方案,帮助开发者构建稳健的高并发应用。

cqwmy840702的博客 292

Android开发工程师核心技能与面试全攻略

移动应用开发中,Android系统作为全球占有率最高的移动操作系统,其开发技术栈持续演进。从基础的Java/Kotlin语言特性到Android四大组件原理,开发者需要建立完整的知识体系。现代Android开发更涉及Jetpack组件库、Compose声明式UI等前沿技术,性能优化与架构设计能力成为区分工程师水平的关键指标。在工程实践中,内存泄漏排查、启动速度优化等场景考验开发者的实战能力。对于求职者而言,掌握Handler机制、Binder IPC等系统原理,以及具备模块化架构设计经验,是通过大厂技术面试

weixin_30236595的博客 368

爱奇艺Android笔试题B卷复盘:从Handler到内存优化的核心考点

Android开发中,Handler消息机制、四大组件生命周期与内存优化是衡量工程师基础功底的重要标尺。理解Looper、MessageQueue与Handler的协作原理,掌握Activity启动时的生命周期回调顺序,能够有效应对并发与性能调优问题。在工程实践中,线程池参数配置、OOM与ANR的成因分析、以及滑动窗口等算法思想,都是大厂笔试的高频考点。本文以爱奇艺Android笔试题B卷为例,还原出题逻辑与答题策略,帮助候选人构建系统化的Android知识体系,从原理到应用全面提升笔试实战能力。

weixin_34413802的博客 356

来自阿里巴巴佛系安卓程序员的指南,Android校招面试指南

前言 首先声明,楼主不是什么大牛,没有多牛逼的技术,只是公司扩招团队,有幸作为技术面试官,面试了这么多人之后的感想,希望对大家有一点点帮助。 Java相关 Java基础 HashMap1.7和1.8的实现原理 final关键字,为什么匿名内部类使用局部引用要用final Java多线程 线程池的使用和原理 锁机制:synchronized、Lock volatile关键字 ThreadLocal原理 JVM Java内存结构 Java垃圾回收机制 Java类加载过程

m0_57064331的博客 140

VS2015+C++实战:手把手教你用海康MVS里的Demo搞定多相机同步采图与保存

本文详细解析了在VS2015+C++环境下,利用海康威视MVS工业相机SDK实现多相机同步采图与保存的全流程。从环境准备、SDK选择到多相机初始化、同步采图方案,再到异常处理与性能优化,提供了实战技巧和代码示例,帮助开发者快速掌握工业相机二次开发的核心技术。

weixin_29170327的博客 283

BAT大厂Android面试核心考点与Java技术深度解析

Java集合框架与多线程编程是Android开发的基石技术,HashMap通过红黑树优化查询效率,ConcurrentHashMap采用CAS+synchronized实现高并发。JVM内存模型中的GC算法与对象布局直接影响应用性能,如Parallel Scavenge收集器处理年轻代回收。在Android平台,Binder机制实现跨进程通信,Handler的MessageQueue处理线程调度,这些原理级知识是优化内存泄漏、启动速度等工程问题的关键。大厂面试尤其注重从Activity启动流程到Jetpac

weixin_34236869的博客 365

sentaurus学习笔记(HFET_pGate_GaN仿真)(五)

`(sdedr:define-constant-profile`和`(sdedr:define-constant-profile-region`命令用于定义并应用一个恒定的活性硼掺杂浓度剖面`"ndop_GaN_gate_const"`到氮化镓栅极层上,其值为`NpGaN_gate`。- `"Oxide"`指定了这一层的材料名称(在这里代表氧化层),而`"nucleation"`是这一层在仿真中的标识名称。- `"GaN"`指定了这一层的材料名称,而`"GaN_gate"`是这一层在仿真中的标识名称。

qq_52640792的博客 941

PSIM仿真实战:反激电源从设计到调试的完整流程(附短路保护配置)

本文详细介绍了使用PSIM仿真工具进行反激电源从设计到调试的完整流程,包括变压器参数设计、功率器件选型、动态特性调试以及短路保护配置。通过实战案例和仿真技巧,帮助工程师提前暴露并解决设计中的常见问题,如负载突变、输入电压波动和短路保护失效等,显著降低硬件试错成本。

weixin_29216353的博客 244

2022年一起努力应对互联网寒冬吧,5G音视频时代还不学NDK开发吗

前言 找工作还是需要大家不要紧张,有我们干这一行的接触人本来就不多 难免看到面试官会紧张,主要是因为怕面试官问的问题到不上来,那时候不要着急 ,答不上了的千万不然胡扯一些,直接就给面试官说这块我还没接触到,以后如果工作当中遇到的话我可以很快的吧这个问题给解决了,但是我们有了这篇文章,就不一样了,基本上问的问题都有适当的看一下,到时候很快就可以拿到 offer 我在这里祝大家工作顺利,天天开心 ~好了下面就是正题。 字节跳动一面 自我介绍 handler机制,sendMessage和post(Runnab

csdn_888999的博客 334

01-认识脑电信号及相关信号的预处理过程

脑电信号处理过程脑电实验为什么要预处理预处理方法降采样如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能,丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 脑电实验 本博客主要是记录基于脑电信号的情绪识别方法的研究...

脑机交流者的博客 7661

2017欢聚时代Android校招笔试A卷复盘:核心考点与备考思路

Android开发求职中,校招笔试往往成为进入大厂的第一道门槛,其考察内容不仅限于API调用,更侧重对Java基础、Handler消息机制、四大组件等底层原理的深度理解。理解这些核心概念,有助于开发者从“会用框架”进阶到“理解系统”,在实际工程中快速定位问题、优化性能。无论是图片加载框架的设计,还是App启动速度优化,背后都离不开对线程通信与资源管理的扎实掌握。本文以欢聚时代2017年Android工程师A卷为样本,系统复盘高频考点与答题思路,为准备Android校招或面试的开发者提供一份可复用的备考思维框

weixin_34167819的博客 379

Multisim实战:从8选1到32选1数据选择器的完整搭建指南(附常见问题解决)

本文提供了一份详尽的Multisim实战指南,手把手教你从基础的8选1数据选择器开始,逐步级联搭建16选1乃至32选1数据选择器。文章深入剖析了级联的核心逻辑、片选方案以及使用译码器的专业方法,并附带了电源连接、输出冲突、信号毛刺等常见问题的诊断与解决技巧,帮助电子工程学生和爱好者扎实掌握数字电路的系统设计与仿真调试。

dd012的博客 732

课设:FPGA音频均衡器 verilog设计及仿真 加报告

未来,随着FPGA技术的进一步发展和应用场景的扩大,FPGA音频均衡器将发挥出更大的作用,并为音频领域带来更多创新和突破。(a)音乐制作:均衡器可以调整音频信号中不同频段的能量分布,使得乐器声音更加明亮、动感,从而提升音乐制作的质量和创作的灵活性。以上步骤提供了设计一个音频均衡器的大致过程,但值得注意的是,具体实现的细节和复杂度可能因设计要求和所使用的平台而有所不同。确保设计满足预期的性能和要求。确定均衡器的功能和要求:定义你的音频均衡器需要实现的功能,包括频率范围、增益范围以及可调参数数量等。

QQ_778132974的博客 1588

京东Android真题复盘:从Java基础到Handler机制与AMS

Android开发岗位的笔试与面试,往往从Java基础与系统机制两个层面同时考察候选人的工程功底。在Java集合、并发编程等基础概念之上,理解HashMap的扩容与树化阈值、volatile的内存语义,是写出稳定代码的前提;而Handler的消息循环、Activity启动模式与AMS的进程管理,则决定了能否定位线上复杂问题。随着工程化程度加深,Gradle构建工具链、代码混淆与R8规则、性能优化也成为高频考点。这些技术不仅支撑电商类App的高并发场景与多版本适配,更是校招笔试和社招回炉的关键得分点。本文以京

weixin_34393428的博客 351

华为面试手撕真题【判断是ipv4还是ipv6地址】

编写一个函数来验证输入的字符串是否是有效的 IPv4 或 IPv6 地址。

MISAYAONE的博客 1万+

顺丰科技安卓笔试客观题全解析:从Java基础到Handler与Binder核心考点

在移动开发岗位的招聘笔试中,客观题往往承担着快速筛选基础能力的作用,其考察范围覆盖Java集合、并发机制、Android组件、消息处理与跨进程通信等核心知识。理解这些技术点的底层原理,不仅是应对选择题的关键,更是工程实践中排查问题、优化性能的基础。例如,HashMap的扩容与红黑树转换、线程池的任务调度策略、Handler消息循环的同步屏障机制,以及Binder一次拷贝的内存映射原理,都是高频考点。屏幕适配与View绘制流程则直接关系到多设备兼容性。顺丰科技安卓笔试将这些通用技术能力与物流场景结合,通过边界

weixin_34133829的博客 280

LLC变压器,常见的4大问题解决方案

其中之一是当付边的绕组的匝数或层数较多的时候,层间或匝间寄生电容和付边的漏感发生一个寄生的振荡,轻载的时候,这个振铃的幅度会达到很高,导致输出电压比设计的要高许多。但当输入是低压的时候,开关频率比较低,LLC谐振回路的增益较大,因而比较容易发生变压器饱和的问题。由于LLC变压器工作在LC谐振状态,LC谐振回路有个特点就是Q值问题,在这里Q值是大于1的,因而就会有实际加在变压器上的电压要比输入电压高的问题,因而在设计变压器的时候就必须考虑到这一点,否则变压器就不是工作在你设计的磁感应强度上。

1268

数学建模模型总结

这是本人在两年内准备参加数学建模竞赛搜集到的模型资料,已经经过了本人的筛选和整理,希望能够对准备参加数学建模竞赛的学弟学妹们提供一些帮助!

android自定义控件开发入门与实战,android开发环境搭建

题外话,我在一线互联网企业工作十余年里,指导过不少同行后辈。帮助很多人得到了学习和成长。我意识到有很多经验和知识值得分享给大家,也可以通过我们的能力和经验解答大家在IT学习中的很多困惑,所以在工作繁忙的情况下还是坚持各种整理和分享。但苦于知识传播途径有限,很多程序员朋友无法获得正确的资料得到学习提升,故此将并将重要的Android进阶资料包括自定义view、性能优化、MVC与MVP与MVVM三大框架的区别、NDK技术、阿里面试题精编汇总、常见源码分析等学习资料。【Android思维脑图(技能树)】

2401_84407849的博客 1292

复分析 阿尔福斯(Ahlfors) 第三版答案 英文

答案分为十章,有部分习题没有答案,全英文复分析阿尔福斯(Ahlfors) 第三版答案

Android面试你必须要知道的那些知识,内含福利

前言 找工作还是需要大家不要紧张,有我们干这一行的接触人本来就不多 难免看到面试官会紧张,主要是因为怕面试官问的问题到不上来,那时候不要着急 ,答不上了的千万不然胡扯一些,直接就给面试官说这块我还没接触到,以后如果工作当中遇到的话我可以很快的吧这个问题给解决了,但是我们有了这篇文章,就不一样了,基本上问的问题都有适当的看一下,到时候很快就可以拿到 offer 我在这里祝大家工作顺利,天天开心 ~好了下面就是正题。 Java相关 Java基础 HashMap1.7和1.8的实现原理 final关键字,为什

m0_56252652的博客 122

深度学习工具包 DeepLearningToolbox

深度学习工具包Deprecation notice.-----This toolbox is outdated and no longer maintained.There are much better tools available for deep learning than this toolbox, e.g. [Theano](http://deeplearning.net/software/theano/), [torch](http://torch.ch/) or [tensorflow](http://www.tensorflow.org/)I would suggest you use one of the tools mentioned above rather than use this toolbox.Best, Rasmus.DeepLearnToolbox================A Matlab toolbox for Deep Learning.Deep Learning is a new subfield of machine learning that focuses on learning deep hierarchical models of data.It is inspired by the human brain's apparent deep (layered, hierarchical) architecture.A good overview of the theory of Deep Learning theory is[Learning Deep Architectures for AI](http://www.iro.umontreal.ca/~bengioy/papers/ftml_book.pdf)For a more informal introduction, see the following videos by Geoffrey Hinton and Andrew Ng.* [The Next Generation of Neural Networks](http://www.youtube.com/watch?v=AyzOUbkUf3M) (Hinton, 2007)* [Recent Developments in Deep Learning](http://www.youtube.com/watch?v=VdIURAu1-aU) (Hinton, 2010)* [Unsupervised Feature Learning and Deep Learning](http://www.youtube.com/watch?v=ZmNOAtZIgIk) (Ng, 2011)If you use this toolbox in your research please cite [Prediction as a candidate for learning deep hierarchical models of data](http://www2.imm.dtu.dk/pubdb/views/publication_details.php?id=6284)```@MASTERSTHESIS\{IMM2012-06284, author = "R. B. Palm", title = "Prediction as a candidate for learning deep hierarchical models of data", year = "2012",}```Contact: rasmusbergpalm at gmail dot comDirectories included in the toolbox-----------------------------------`NN/` - A library for Feedforward Backpropagation Neural Networks`CNN/` - A library for Convolutional Neural Networks`DBN/` - A library for Deep Belief Networks`SAE/` - A library for Stacked Auto-Encoders`CAE/` - A library for Convolutional Auto-Encoders`util/` - Utility functions used by the libraries`data/` - Data used by the examples`tests/` - unit tests to verify toolbox is workingFor references on each library check REFS.mdSetup-----1. Download.2. addpath(genpath('DeepLearnToolbox'));Example: Deep Belief Network---------------------```matlabfunction test_example_DBNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit RBM and visualize its weightsrand('state',0)dbn.sizes = [100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);figure; visualize(dbn.rbm{1}.W'); % Visualize the RBM weights%% ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NNrand('state',0)%train dbndbn.sizes = [100 100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);%unfold dbn to nnnn = dbnunfoldtonn(dbn, 10);nn.activation_function = 'sigm';%train nnopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.10, 'Too big error');```Example: Stacked Auto-Encoders---------------------```matlabfunction test_example_SAEload mnist_uint8;train_x = double(train_x)/255;test_x = double(test_x)/255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit SDAE and use it to initialize a FFNN% Setup and train a stacked denoising autoencoder (SDAE)rand('state',0)sae = saesetup([784 100]);sae.ae{1}.activation_function = 'sigm';sae.ae{1}.learningRate = 1;sae.ae{1}.inputZeroMaskedFraction = 0.5;opts.numepochs = 1;opts.batchsize = 100;sae = saetrain(sae, train_x, opts);visualize(sae.ae{1}.W{1}(:,2:end)')% Use the SDAE to initialize a FFNNnn = nnsetup([784 100 10]);nn.activation_function = 'sigm';nn.learningRate = 1;nn.W{1} = sae.ae{1}.W{1};% Train the FFNNopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.16, 'Too big error');```Example: Convolutional Neural Nets---------------------```matlabfunction test_example_CNNload mnist_uint8;train_x = double(reshape(train_x',28,28,60000))/255;test_x = double(reshape(test_x',28,28,10000))/255;train_y = double(train_y');test_y = double(test_y');%% ex1 Train a 6c-2s-12c-2s Convolutional neural network %will run 1 epoch in about 200 second and get around 11% error. %With 100 epochs you'll get around 1.2% errorrand('state',0)cnn.layers = { struct('type', 'i') %input layer struct('type', 'c', 'outputmaps', 6, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %sub sampling layer struct('type', 'c', 'outputmaps', 12, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %subsampling layer};cnn = cnnsetup(cnn, train_x, train_y);opts.alpha = 1;opts.batchsize = 50;opts.numepochs = 1;cnn = cnntrain(cnn, train_x, train_y, opts);[er, bad] = cnntest(cnn, test_x, test_y);%plot mean squared errorfigure; plot(cnn.rL);assert(er<0.12, 'Too big error');```Example: Neural Networks---------------------```matlabfunction test_example_NNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);% normalize[train_x, mu, sigma] = zscore(train_x);test_x = normalize(test_x, mu, sigma);%% ex1 vanilla neural netrand('state',0)nn = nnsetup([784 100 10]);opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samples[nn, L] = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.08, 'Too big error');%% ex2 neural net with L2 weight decayrand('state',0)nn = nnsetup([784 100 10]);nn.weightPenaltyL2 = 1e-4; % L2 weight decayopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex3 neural net with dropoutrand('state',0)nn = nnsetup([784 100 10]);nn.dropoutFraction = 0.5; % Dropout fraction opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex4 neural net with sigmoid activation functionrand('state',0)nn = nnsetup([784 100 10]);nn.activation_function = 'sigm'; % Sigmoid activation functionnn.learningRate = 1; % Sigm require a lower learning rateopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex5 plotting functionalityrand('state',0)nn = nnsetup([784 20 10]);opts.numepochs = 5; % Number of full sweeps through datann.output = 'softmax'; % use softmax outputopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex6 neural net with sigmoid activation and plotting of validation and training error% split training data into training and validation datavx = train_x(1:10000,:);tx = train_x(10001:end,:);vy = train_y(1:10000,:);ty = train_y(10001:end,:);rand('state',0)nn = nnsetup([784 20 10]); nn.output = 'softmax'; % use softmax outputopts.numepochs = 5; % Number of full sweeps through dataopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, tx, ty, opts, vx, vy); % nntrain takes validation set as last two arguments (optionally)[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');```[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/rasmusbergpalm/deeplearntoolbox/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

efm32 入门.pdf

本PDF共计22页,介绍的是操作驱动API,下载与否自己斟酌。

99 道 Java 多线程面试题,看完我跪了!

今天给大家更新的是一篇关于多线程面试的文章,是根据时下热门的面试内容给大家进行总结的,如有雷同,请多见谅!本篇文章属于干货内容!请各位读者朋友一定要坚持读到最后,完整阅读本文后相信你对多...

Java和Android架构 594

京东Android校招笔试复盘:核心考点与备考指南

在Android开发岗位的校招中,笔试环节往往考察的是开发者对底层原理与基础知识的掌握程度。从Java集合框架到并发编程,从Handler消息机制到Activity启动模式,这些核心技术点贯穿于日常开发与面试考核之中。理解HashMap的底层实现、线程池的运行流程、Binder的通信原理,不仅能应对大厂笔试,更能提升实际工程中的问题排查能力。本文基于京东2019校招Android笔试题,系统梳理了Java基础、Android核心机制、数据结构与算法、网络协议等高频考点,并针对备考优先级、常见陷阱和技术面追问

weixin_30509393的博客 397

自学Android,面试被怼,看我如何拿下阿里offer

一面(1小时)重载与重写final修饰符抽象类和接口GC机制、原理finalize( )的理解GC机制如何判定哪些对象需要回收GCRoots有哪些四种引用垃圾收集算法Hash Map与Hash table的区别怎么让Hash map线程安全Thead Loocal了解吗?线程同步的几种方式加锁与synchromized区别Volatile 了解吗JVM内存模型leakCanary内部机制Handler内部机制MNC与MVP的区别,以登陆模块为例讲一下每层的工作EventBus的原理布局优化 include.

2401_84149814的博客 739
上一篇: 如何应对Android面试官->Retrofit中注解、反射、动态代理、手写实现
下一篇: 如何应对Android面试官->CAS基本原理
老A说
博客等级 码龄14年 1181粉丝 85原创
评论 1
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值