精华内容
下载资源
问答
  • Android如何安全关闭线程

    万次阅读 2019-01-04 15:57:50
    正常情况下,当线程中的run方法执行完毕后,线程是会自动关闭,不需要我们手动去关闭的。  如: new Thread(new Runnable() {  @Override  public void run() {  //执行操作  } }).start(); 该线程...

    正常情况下,当线程中的run方法执行完毕后,线程是会自动关闭,不需要我们手动去关闭的。

     如:

    new Thread(new Runnable() {
        @Override
        public void run() {
            //执行操作
        }
    
    }).start();

    该线程在run方法中的操作执行完毕后,线程会自动关闭。

     

    而当run方法中的操作会不断循环执行时如:

    new Thread(new Runnable() {
        @Override
        public void run() {
            while (true){
                //执行操作
            }
        }
    
    }).start();

    这个线程中run方法会循环执行,并不会中断,所以线程一会一直执行,Android中如果不做终止,即使退出activity也会一直执行,所以我们需要手动终止线程,终止线程的方法:

    1.Thread.stop(),该方法是暴力停止线程不推荐使用,已经废弃。

    2.使用标记位来停止,如下面例子,如果我们要在activity 销毁时退出线程:

    private void stopThread(){
        mThread = new Thread(new Runnable() {
            @Override
            public void run() {
                while (true){
                    //执行操作
                    if (isStopThread){
                        break;
                    }
                }
            }
        });
        mThread.start();
    }
    
    @Override
    protected void onDestroy() {
        super.onDestroy();
        isStopThread = true;
    
    }
    
    

    isStopThread变量来判断是否退出线程,如需要退出就直接退出循环,线程终止。

    3.使用interrupt方法来停止线程:

    private void stopThread(){
        mThread = new Thread(new Runnable() {
            @Override
            public void run() {
                while (true){
                    //执行操作
                    if (mThread.isInterrupted()){
                        break;
                    }
                }
            }
        });
        mThread.start();
    }
    
    @Override
    protected void onDestroy() {
        super.onDestroy();
        mThread.interrupt();
    
    }
    
    

    我们使用mThread.interrupt来中断线程,在run方法中使用mThread.isInterrupted()来判断线程是否中断,如果中断责跳出循环,这个标识位的原理其实是一样的。mThread.interrupt并不是强行中断线程,只是给线程设置一个标志,告诉线程我需要中断。

     

    接下来我们看下线程阻塞的情况下:

    private void stopThread(){
        mThread = new Thread(new Runnable() {
            @Override
            public void run() {
                while (true){
                    //执行操作
                    Log.e(TAG,"线程执行中..is interrupted = " + mThread.isInterrupted());
                    if (mThread.isInterrupted()){
                        break;
                    }
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                        Log.e(TAG,"出现异常");
                    }
    
                }
            }
        });
        mThread.start();
    }
    
    @Override
    protected void onDestroy() {
        super.onDestroy();
        Log.e(TAG,"退出activity");
        mThread.interrupt();
    
    }
    
    

    我们看下log:

     

    从log中我们看到退出activity时,线程阻塞抛出了异常,而mThread.isInterrupted()仍然为false,所以线程并没有被中断,这是因为现在进入阻塞时调用mThread.interrupt()方法,会抛出异常同时还会调用interrupted()方法,把isInterrupted恢复称false,所以线程不会被终止,

    解决方法很简单我们只要在出现异常中退出循环就可以了:

    while (true){
        //执行操作
        Log.e(TAG,"线程执行中..is interrupted = " + mThread.isInterrupted());
        if (mThread.isInterrupted()){
            break;
        }
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
            Log.e(TAG,"出现异常");
            break;
        }
    
    }

     

    展开全文
  • Delphi线程安全关闭

    千次阅读 2008-07-14 11:02:00
    在Delphi中使用线程,当窗体关闭时,如果窗体中启用了线程,一般需要手动关闭,以释放资源。常用来结束线程的代码为: PcmThrd.Terminate; PcmThrd.WaitFor;即先触发Terminate方法,然后等待线程的结束。这种方法...

     在Delphi中使用线程,当窗体关闭时,如果窗体中启用了线程,一般需要手动关闭,以释放资源。

    常用来结束线程的代码为:

            PcmThrd.Terminate;
            PcmThrd.WaitFor;

    即先触发Terminate方法,然后等待线程的结束。

    这种方法要求线程不能使用 FreeOnTerminate := True; ,否则在WaitFor即将结束的时候会引发“无效句柄”的错误。

    这种方法在窗体关闭的时候会等待一段事件(因为WaitFor)。

     

    因此,如果不是在主窗体中结束线程时,其实我们可以不必使用WaitFor。而是采用如下方法:

    将FreeOnTerminate := True;

    这样在窗体关闭的代码中直接调用

            PcmThrd.Terminate;

    即可。

    注意:

    如果设置了

        PcmThrd.OnTerminate := SomeFunction;

    那么在调用PcmThrd.Terminate;前尽量将PcmThrd.OnTerminate := nil,以免结束线程后SomeFunction中的变量出现空指针错误。当然,这不是绝对的,需要根据具体程序而定。

     

    展开全文
  • 同步锁-线程安全问题解决方案

    万次阅读 多人点赞 2021-03-21 15:12:05
    经过前面多线程编程的学习,我们遇到了线程安全的相关问题,比如多线程售票情景下的超卖/重卖现象. 上节笔记点这里-进程与线程笔记 我们如何判断程序有没有可能出现线程安全问题,主要有以下三个条件: 在多线程程序中 +...

    1 同步锁

    1.1 前言

    经过前面多线程编程的学习,我们遇到了线程安全的相关问题,比如多线程售票情景下的超卖/重卖现象.
    上节笔记点这里-进程与线程笔记

    我们如何判断程序有没有可能出现线程安全问题,主要有以下三个条件:

    在多线程程序中 + 有共享数据 + 多条语句操作共享数据

    多线程的场景和共享数据的条件是改变不了的(就像4个窗口一起卖100张票,这个是业务)
    所以思路可以从第3点"多条语句操作共享数据"入手,既然是在这多条语句操作数据过程中出现了问题
    那我们可以把有可能出现问题的代码都包裹起来,一次只让一个线程来执行

    1.2 同步与异步

    那怎么"把有可能出现问题的代码都包裹起来"呢?我们可以使用synchronized关键字来实现同步效果
    也就是说,当多个对象操作共享数据时,可以使用同步锁解决线程安全问题,被锁住的代码就是同步的

    接下来介绍下同步与异步的概念:
    同步:体现了排队的效果,同一时刻只能有一个线程独占资源,其他没有权利的线程排队。
    坏处就是效率会降低,不过保证了安全。
    异步:体现了多线程抢占资源的效果,线程间互相不等待,互相抢占资源。
    坏处就是有安全隐患,效率要高一些。

    1.3 synchronized同步关键字

    1.3.1 写法

    synchronized (锁对象){
    需要同步的代码(也就是可能出现问题的操作共享数据的多条语句);
    }

    1.3.2 前提

    同步效果的使用有两个前提:

    • 前提1:同步需要两个或者两个以上的线程(单线程无需考虑多线程安全问题)
    • 前提2:多个线程间必须使用同一个锁(我上锁后其他人也能看到这个锁,不然我的锁锁不住其他人,就没有了上锁的效果)

    1.3.3 特点

    1. synchronized同步关键字可以用来修饰代码块,称为同步代码块,使用的锁对象类型任意,但注意:必须唯一!
    2. synchronized同步关键字可以用来修饰方法,称为同步方法
    3. 同步的缺点是会降低程序的执行效率,但我们为了保证线程的安全,有些性能是必须要牺牲的
    4. 但是为了性能,加锁的范围需要控制好,比如我们不需要给整个商场加锁,试衣间加锁就可以了

    为什么同步代码块的锁对象可以是任意的同一个对象,但是同步方法使用的是this呢?
    因为同步代码块可以保证同一个时刻只有一个线程进入
    但同步方法不可以保证同一时刻只能有一个线程调用,所以使用本类代指对象this来确保同步

    同步与异步

    1.4.1练习-改造售票案例

    创建包: cn.tedu.tickets
    创建类:TestRunnableV2.java

    package cn.tedu.tickets;
    
    /*本类用于改造多线程售票案例,解决数据安全问题*/
    public class TestRunnableV2 {
        public static void main(String[] args) {
            //5.创建目标业务类对象
            TicketR2 target = new TicketR2();
            //6.创建线程对象
            Thread t1 = new Thread(target);
            Thread t2 = new Thread(target);
            Thread t3 = new Thread(target);
            Thread t4 = new Thread(target);
            //7.以多线程的方式运行
            t1.start();
            t2.start();
            t3.start();
            t4.start();
        }
    }
    
    /*1.多线程中出现数据安全问题的原因:多线程程序+共享数据+多条语句操作共享数据*/
    /*2.同步锁:相当于给容易出现问题的代码加了一把锁,包裹了所有可能会出现数据安全问题的代码
     * 加锁之后,就有了同步(排队)的效果,但是加锁的话,需要考虑:
     * 锁的范围:不能太大,太大,干啥都得排队,也不能太小,太小,锁不住,还是会有安全隐患*/
    //1.创建自定义多线程类
    class TicketR2 implements Runnable {
        //3.定义成员变量,保存票数
        int tickets = 100;
        //创建锁对象
        Object o = new Object();
    
        //2.实现接口中未实现的方法,run()中放着的是我们的业务
        @Override
        public void run() {
            //4.通过循环结构完成业务
            while (true) {
                /*3.同步代码块:synchronized(锁对象){会出现安全隐患的所有代码}
                 * 同步代码块在同一时刻,同一资源只会被一个线程独享*/
                /*这种写法不对,相当于每个线程进来的时候都会new一个锁对象,线程间使用的并不是同一把锁*/
                //synchronized (new Object()){
                //修改同步代码块的锁对象为成员变量o,因为锁对象必须唯一
                synchronized (o) {//同步代码块解决的是重卖的问题
                    //如果票数>0就卖票
                    if (tickets > 0) {
                        try {
                            Thread.sleep(10);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        //4.1打印当前正在售票的线程名以及票数-1
                        System.out.println(Thread.currentThread().getName() + "=" + tickets--);
                    }
                    //4.2退出死循环--没票的时候就结束
                    if (tickets <= 0) break;
                }
            }
        }
    }
    

    1.4.2 练习-改造售票案例

    创建包: cn.tedu.tickets
    创建类:TestThreadV2.java

    package cn.tedu.tickets;
    
    /*本类用于改造多线程售票案例,解决数据安全问题*/
    public class TestThreadV2 {
        public static void main(String[] args) {
            //5.创建多个线程对象并以多线程的方式运行
            TickectT2 t1 = new TickectT2();
            TickectT2 t2 = new TickectT2();
            TickectT2 t3 = new TickectT2();
            TickectT2 t4 = new TickectT2();
            t1.start();
            t2.start();
            t3.start();
            t4.start();
        }
    }
    
    //1.自定义多线程类
    class TickectT2 extends Thread {
        //3.新增成员变量用来保存票数
        static int tickets = 100;
        //static Object o = new Object();
    
        //2.添加重写的run()来完成业务
        @Override
        public void run() {
            //3.创建循环结构用来卖票
            while (true) {
                //Ctrl+Alt+L调整代码缩进
                //7.添加同步代码块,解决数据安全问题
                //synchronized (new Object()) {
                /*static的Object的对象o这种写法也可以*/
                //synchronized (o) {
                /*我们每通过class关键字创建一个类,就会在工作空间中生成一个唯一对应的类名.class字节码文件
                * 这个类名.class对应的对象我们称之为这个类的字节码对象
                * 字节码对象极其重要,是反射技术的基石,字节码对象中包含了当前类所有的关键信息
                * 所以,用这样一个唯一且明确的对象作为同步代码块的锁对象,再合适不过了*/
                synchronized (TickectT2.class) {/*比较标准的写法*/
                    if(tickets > 0){
                        //6.添加线程休眠,暴露问题
                        try {
                            Thread.sleep(10);//让线程休眠,增加线程状态切换的频率
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        //4.1打印当前正在售票的线程名与票数-1
                        System.out.println(getName() + "=" + tickets--);
                    }
                    //4.2给程序设置一个出口,没有票的时候就停止卖票
                    if (tickets <= 0) break;
                }
            }
        }
    }
    

    注意:如果是继承的方式的话,锁对象最好用"类名.class",否则创建自定义线程类多个对象时,无法保证锁的唯一

    1.5 之前遇到过的同步例子

    StringBuffer JDK1.0
    加了synchronized ,性能相对较低(要排队,同步),安全性高
    StringBuilder JDK1.5
    去掉了synchronized,性能更高(不排队,异步),存在安全隐患
    其他同步异步的例子

    快速查找某个类的快捷键:Ctrl+Shift+T

    2 线程创建的其他方式

    2.1 ExecutorService/Executors

    ExecutorService:用来存储线程的池子,把新建线程/启动线程/关闭线程的任务都交给池来管理

    • execute(Runnable任务对象) 把任务丢到线程池

    Executors 辅助创建线程池的工具类

    • newFixedThreadPool(int nThreads) 最多n个线程的线程池
    • newCachedThreadPool() 足够多的线程,使任务不必等待
    • newSingleThreadExecutor() 只有一个线程的线程池

    2.2 练习:线程的其他创建方式

    创建包: cn.tedu.tickets
    创建类: TestThreadPool.java

    package cn.tedu.tickets;
    
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    /*本类用于测试线程池*/
    public class TestThreadPool {
        public static void main(String[] args) {
            //5.创建接口实现类TicketR3类的对象作为目标业务对象
            TicketR3 target = new TicketR3();
            /*Executors是用来辅助创建线程池的工具类对象
            * 常用方法是newFixedThreadPool(int)这个方法可以创建指定数目的线程池对象
            * 创建出来的线程池对象是ExecutorService:用来存储线程的池子,负责:新建/启动/关闭线程*/
            //6.使用Executors工具创建一个最多有5个线程的线程池对象ExecutorService池对象
            ExecutorService pool = Executors.newFixedThreadPool(5);
            for (int i = 0; i < 5; i++) {
                /*execute()让线程池中的线程来执行业务,每次调用都会将一个线程加入到就绪队列*/
                pool.execute(target);/*本方法的参数就是你要执行的业务,也就是目标业务类对象*/
            }
        }
    }
    //同步锁问题解决方案笔记:1.4.1从26行复制到58行,TicketR2改成TicketR3
    //1.创建自定义多线程类
    class TicketR3 implements Runnable {
        //3.定义成员变量,保存票数
        int tickets = 100;
        //创建锁对象
        Object o = new Object();
    
        //2.实现接口中未实现的方法,run()中放着的是我们的业务
        @Override
        public void run() {
            //4.通过循环结构完成业务
            while (true) {
                /*3.同步代码块:synchronized(锁对象){会出现安全隐患的所有代码}
                 * 同步代码块在同一时刻,同一资源只会被一个线程独享*/
                /*这种写法不对,相当于每个线程进来的时候都会new一个锁对象,线程间使用的并不是同一把锁*/
                //synchronized (new Object()){
                //修改同步代码块的锁对象为成员变量o,因为锁对象必须唯一
                synchronized (o) {//同步代码块解决的是重卖的问题
                    //如果票数>0就卖票
                    if (tickets > 0) {
                        try {
                            Thread.sleep(10);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        //4.1打印当前正在售票的线程名以及票数-1
                        System.out.println(Thread.currentThread().getName() + "=" + tickets--);
                    }
                    //4.2退出死循环--没票的时候就结束
                    if (tickets <= 0) break;
                }
            }
        }
    }
    

    3 拓展:线程锁

    3.1 悲观锁和乐观锁

    悲观锁:像它的名字一样,对于并发间操作产生的线程安全问题持悲观状态.
    悲观锁认为竞争总是会发生,因此每次对某资源进行操作时,都会持有一个独占的锁,就像synchronized,不管三七二十一,直接上了锁就操作资源了。

    乐观锁:还是像它的名字一样,对于并发间操作产生的线程安全问题持乐观状态.
    乐观锁认为竞争不总是会发生,因此它不需要持有锁,将”比较-替换”这两个动作作为一个原子操作尝试去修改内存中的变量,如果失败则表示发生冲突,那么就应该有相应的重试逻辑。

    3.2 两种常见的锁

    synchronized 互斥锁(悲观锁,有罪假设)

    采用synchronized修饰符实现的同步机制叫做互斥锁机制,它所获得的锁叫做互斥锁。
    每个对象都有一个monitor(锁标记),当线程拥有这个锁标记时才能访问这个资源,没有锁标记便进入锁池。任何一个对象系统都会为其创建一个互斥锁,这个锁是为了分配给线程的,防止打断原子操作。每个对象的锁只能分配给一个线程,因此叫做互斥锁。

    ReentrantLock 排他锁(悲观锁,有罪假设)

    ReentrantLock是排他锁,排他锁在同一时刻仅有一个线程可以进行访问,实际上独占锁是一种相对比较保守的锁策略,在这种情况下任何“读/读”、“读/写”、“写/写”操作都不能同时发生,这在一定程度上降低了吞吐量。然而读操作之间不存在数据竞争问题,如果”读/读”操作能够以共享锁的方式进行,那会进一步提升性能。

    ReentrantReadWriteLock 读写锁(乐观锁,无罪假设)

    因此引入了ReentrantReadWriteLock,顾名思义,ReentrantReadWriteLock是Reentrant(可重入)Read(读)Write(写)Lock(锁),我们下面称它为读写锁。
    读写锁内部又分为读锁和写锁,读锁可以在没有写锁的时候被多个线程同时持有,写锁是独占的。
    读锁和写锁分离从而提升程序性能,读写锁主要应用于读多写少的场景。

    3.3 尝试用读写锁改造售票案例

    package cn.tedu.thread;
    
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    import java.util.concurrent.locks.ReentrantReadWriteLock;
    
    /**
     * 本类用于改造售票案例,使用可重入读写锁
     * ReentrantReadWriteLock
     * */
    public class TestSaleTicketsV3 {
    	public static void main(String[] args) {
    		SaleTicketsV3 target = new SaleTicketsV3();
    		Thread t1 = new Thread(target);
    		Thread t2 = new Thread(target);
    		Thread t3 = new Thread(target);
    		Thread t4 = new Thread(target);
    		t1.start();
    		t2.start();
    		t3.start();
    		t4.start();
    	}
    }
    class SaleTicketsV3 implements Runnable{
    	static int tickets = 100;
    	//1.定义可重入读写锁对象,静态保证全局唯一
    	static ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
    	@Override
    	public void run() {
    		while(true) {
    			//2.在操作共享资源前上锁
    			lock.writeLock().lock();
    			try {
    				if(tickets > 0) {
    					try {
    						Thread.sleep(10);
    					} catch (InterruptedException e) {
    						e.printStackTrace();
    					}
    					System.out.println(Thread.currentThread().getName() + "=" + tickets--);
    				}
    				if(tickets <= 0) break;
    			} catch (Exception e) {
    				e.printStackTrace();
    			}finally {
    				//3.finally{}中释放锁,注意一定要手动释放,防止死锁,否则就独占报错了
    				lock.writeLock().unlock();
    			}
    		}
    	}
    } 
    

    3.4 两种方式的区别

    需要注意的是,用sychronized修饰的方法或者语句块在代码执行完之后锁会自动释放,而是用Lock需要我们手动释放锁,所以为了保证锁最终被释放(发生异常情况),要把互斥区放在try内,释放锁放在finally内!
    与互斥锁相比,读-写锁允许对共享数据进行更高级别的并发访问。虽然一次只有一个线程(writer 线程)可以修改共享数据,但在许多情况下,任何数量的线程可以同时读取共享数据(reader 线程)从理论上讲,与互斥锁定相比,使用读-写锁允许的并发性增强将带来更大的性能提高。

    恭喜你,线程与线程锁的学习可以暂时告一段落啦,接着我们可以继续学习别的内容

    下一节 设计模式 点这里

    展开全文
  • Android中循环线程安全关闭方法

    千次阅读 2013-09-30 21:31:19
    /**循环线程关闭**/ try {  FRIDReadWriteThreadUtils rfidThread = new FRIDReadWriteThreadUtils();  rfidThread.start();  rfidThread.join(100);  rfidThread.interrupt();  while(rfidTh

    /**循环线程的关闭**/

    try {
         FRIDReadWriteThreadUtils rfidThread = new  FRIDReadWriteThreadUtils();
         rfidThread.start();
         rfidThread.join(100);
         rfidThread.interrupt();
         while(rfidThread.isAlive()){
          rfidThread.setCloseThread(false);
          rfidThread.join(1);
         }
         if(rfidThread.isAlive()){
          Toast.makeText(MainActivity.this, "RFID读写线程还存在", 0).show();
         }else{
          Toast.makeText(MainActivity.this, "RFID读写线程死亡", 0).show();
         }
         rfidThread.sendData("sssssssssss");
        } catch (InterruptedException e) {
         // TODO Auto-generated catch block
         e.printStackTrace();
        }

     

     

    /**循环线程**/

    package utils;

    import android.util.Log;

    public class FRIDReadWriteThreadUtils extends Thread{
     
     private boolean isCloseThread = true;
     
     @Override
     public void run() {
      // TODO Auto-generated method stub 
      super.run();
      int i = 0;
      while(this.isCloseThread){
       //System.out.println(i);
       Log.v("thread", i+"");
       i++;
      }
      
     }
     /**
      * 通过蓝牙发送数据
      * */
     public void sendData(String str){
      Log.v("sendData", str);
     }
     
     public boolean isCloseThread() {
      return isCloseThread;
     }

     public void setCloseThread(boolean isCloseThread) {
      this.isCloseThread = isCloseThread;
     }
     
    }

    展开全文
  • Servlet的多线程和线程安全

    千次阅读 2016-09-04 17:41:41
    Servlet的多线程和线程安全线程安全 首先说明一下对线程安全的讨论,哪种情况我们可以称作线程安全? 网上对线程安全有很多描述,我比较喜欢《Java并发编程实战》给出的定义,“当多个线程访问某个类时,不管运行时...
  • Redis线程安全问题

    万次阅读 2019-05-16 17:29:26
    Redis是线程安全的吗? Redis是个单线程程序,所以它是线程安全的。 Redis单线程为什么还能这么快? Redis是基于内存的,内存的读写速度非常快; Redis是单线程的,避免了不必要的上下文切换和竞争条件; ...
  • 我先简单举一个线程安全的例子 大家请自觉把i–当作银行取款过程,基本所有线程例子都是以银行取款为例,因为银行取款是最需要安全线程的了 public class demo1 extends Thread{ private int i=10; @Override ...
  • Window线程安全与线程控制函数

    万次阅读 2020-06-21 03:17:52
    线程安全问题 多线程同时访问全局变量:一个线程取值后失去CPU另一个线程取值后也失去CPU,此时它们保存的就是相同的值。也是是说,比如两个线程再次对全区变量做++操作时变量只会被修改为同样的值。 二. 临界...
  • 安卓线程安全

    千次阅读 2018-07-16 16:20:07
    UI线程安全 耗时操作不在UI线程,否则会引发NAR,影响用户体验 UI非线程安全,不在其他线程操作UI。 既然像网络操作这种耗时的操作不能在主线程,而其他线程又不能更新UI。于是安卓提供了Handler和Looper。 可一...
  • mfc安全退出线程

    2018-01-25 19:11:33
    mfc安全退出线程mfc安全退出线程mfc安全退出线程mfc安全退出线程mfc安全退出线程
  • 线程安全FMDatabaseQueue 数据库单例封装Demo
  • java多线程开发 如何正确关闭线程

    万次阅读 2016-04-19 23:31:33
    在java高级开发中,经常会碰到多线程,关于线程关闭,可能会用stop() 方法,但是stop是线程安全的,一般采用interrupt,判断线程是否中止采用isInterrupted, 如果线程中有Thread.sleep方法,当设置中断后,...
  • C# 多线程模式 关闭/退出全部线程

    千次阅读 2014-03-22 23:03:24
    今天使用VS调试一个Http服务器,其中使用了多个Thread来多线程处理Request,发现在调试模式下,关闭程序时,VS还处于调试模式,猜测是因为有Thread没有结束   Google 一下, 得出以下解决方法 Thread.IsBackground ...
  • c#线程关闭

    千次阅读 2017-11-12 00:04:47
    注意!...大家都知道在C#里面,我们可以使用 Thread.Start方法来启动一个线程,当我们想停止执行的线程时可以使用Thread.Abort方法来强制停止正在执行的线程,但是请注意,你确定调用了Thread.Abor
  • Redis到底是多线程还是单线程?线程安全

    万次阅读 多人点赞 2018-07-17 11:45:51
    redis是单线程,线程安全 redis可以能够快速执行的原因: (1) 绝大部分请求是纯粹的内存操作(非常快速) (2) 采用单线程,避免了不必要的上下文切换和竞争条件 (3) 非阻塞IO - IO多路复用(IO 多路复用是什么意思...
  • 在Android开发中,经常会碰到多线程,关于线程关闭,可能会用stop() 方法,但是stop是线程安全的,一般采用interrupt,判断线程是否中止采用isInterrupted, 如果线程中有Thread.sleep方法,当设置中断后,执行...
  • java多线程创建方式以及线程安全

    千次阅读 多人点赞 2021-05-11 10:53:53
    什么是线程 线程被称为轻量级进程,是程序执行的最小单位,它是指在程序执行过程中,能够执行代码的一个执行单位。每个程序程序都至少有一个线程,也即是程序本身。 线程的状态 新建(New):创建后尚未启动的...
  • java线程安全和锁优化

    千次阅读 2016-04-10 16:17:43
    线程安全的一个恰当的定义:当多个线程访问一个对象时,如果不用考虑这些线程在运行环境下的调度和交替执行,也不需要进行额外的同步,或者在调用方进行任何其他的协调操作,调用这个对象的行为都可以获得正确的结果...
  • SpringBoot单实例与线程安全总结

    千次阅读 2019-03-01 11:03:49
    SpringBoot单实例与线程安全总结 一、Spring单例模式与线程安全 Spring框架里的bean,或者说组件,获取实例的时候都是默认的单例模式,这是在多线程开发的时候要尤其注意的地方。 单例模式的意思就是只有一个实例...
  • 在使用cancel关闭线程 例下 QFuture<void> f1= QtConcurrent::run([&filepath,&data](){ QFile file(filepath); file.open(QIODevice::WriteOnly); file.write(data); file.waitForBytesWritten...
  • 而正当有多个线程同时对某变量执行读和写操作,一般都需要考虑线程同步,否则就可能读到的是脏数据而影响线程安全。 可以采用加锁、ThreadLocal维护的方式控制,达到线程安全 锁 java的synchronized ...
  • Java并发:线程安全与锁优化

    千次阅读 2018-01-01 18:25:15
    概述人们很难想象现实中的对象在一项工作进行期间,会被不停地中断和切换,对象的属性(数据)可能会在中断期间被修改和变“脏”,而这些事情在计算机世界中则是很正常的事情。...1.线程安全《Java Co...
  • 连接数据库connection定义为成员变量(private,非静态),为什么会出现线程安全问题?其他线程使用了活跃的connection,结果给提前关闭
  • 线程安全与锁优化

    千次阅读 2016-08-12 15:14:41
     本章介绍了线程安全所涉及的概念和分类、同步实现的方式及虚拟机的底层运作原理,并且介绍了虚拟机为了实现高效并发所采取的一系列锁优化措施。 许多资深的程序员都说过,能够写出高伸缩性的并发程序是一门艺术,...
  • java线程取消与关闭

    千次阅读 2017-03-07 22:36:55
    java线程取消与关闭java并未提供任何机制来安全的终止线程。但它提供了中断,这是一种协作机制,能够使一个线程终止另外一个线程的当前工作。任务取消在java中没有一种安全的抢占式方法来停止线程,因此也就没有一种...
  • Hibernate中SessionFactory是线程安全的吗?Session是线程安全的吗(两个线程能够共享同一个Session吗)? SessionFactory对应Hibernate的一个数据存储的概念,它是线程安全的,可以被多个线程并发访问。 ...
  • i++线程安全问题

    千次阅读 2018-04-26 00:40:33
    Q:i++是线程安全的吗?A:如果是局部变量,那么i++是线程安全。 如果是全局变量,那么i++不是线程安全的。理由:如果是局部变量,那么i++是线程安全:局部变量其他线程访问不到,所以根本不存在是否安全这个问题。...
  • linux下 c中怎么让才能安全关闭线程

    万次阅读 2012-05-05 10:05:32
    线程退出有三种方式: (1)执行完成后隐式退出; (2)由线程本身显示调用pthread_exit 函数退出;  pthread_exit (void * retval) ;  (3)被其他线程用pthread_cance函数终止:  pthread_cance ...
  • STL的线程安全解决方案

    千次阅读 2016-08-02 15:37:56
    由于STL不是线程安全的, 所以在每一次插入元素,删除元素,读取元素时,必须保证原子操作. 读取元素也许要原子? 嗯,是的. 因为你得到了一个迭代器后, 这个迭代器对应的容器可能被别的线程修改! 所以(下面来自...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 246,310
精华内容 98,524
关键字:

线程如何安全的关闭