实例代码讲解JAVA多线程

进程与线程

进程是程序的一次动态执行过程,它需要经历从代码加载,代码执行到执行完毕的一个完整的过程,这个过程也是进程本身从产生,发展到最终消亡的过程。多进程操作系统能同时达运行多个进程(程序),由于 CPU 具备分时机制,所以每个进程都能循环获得自己的CPU 时间片。由于 CPU 执行速度非常快,使得所有程序好像是在同时运行一样。

多线程是实现并发机制的一种有效手段。进程和线程一样,都是实现并发的一个基本单位。线程是比进程更小的执行单位,线程是进程的基础之上进行进一步的划分。所谓多线程是指一个进程在执行过程中可以产生多个更小的程序单元,这些更小的单元称为线程,这些线程可以同时存在,同时运行,一个进程可能包含多个同时执行的线程。进程与线程的区别如图所示:

Java中线程实现的方式

在 Java 中实现多线程有两种手段,一种是继承 Thread 类,另一种就是实现 Runnable 接口。下面我们就分别来介绍这两种方式的使用。

实现 Runnable 接口

package ljz;
class MyThread implements Runnable{ // 实现Runnable接口,作为线程的实现类
  private String name ;    // 表示线程的名称
  public MyThread(String name){
    this.name = name ;   // 通过构造方法配置name属性
  }
  public void run(){ // 覆写run()方法,作为线程 的操作主体
    for(int i=0;i<10;i++){
      System.out.println(name + "运行,i = " + i) ;
    }
  }
};
public class RunnableDemo01{
  public static void main(String args[]){
    MyThread mt1 = new MyThread("线程A ") ;  // 实例化对象
    MyThread mt2 = new MyThread("线程B ") ;  // 实例化对象
    Thread t1 = new Thread(mt1) ;    // 实例化Thread类对象
    Thread t2 = new Thread(mt2) ;    // 实例化Thread类对象
    t1.start() ;  // 启动多线程
    t2.start() ;  // 启动多线程
  }
};

程序运行结果:

继承 Thread 类

class MyThread extends Thread{ // 继承Thread类,作为线程的实现类
  private String name ;    // 表示线程的名称
  public MyThread(String name){
    this.name = name ;   // 通过构造方法配置name属性
  }
  public void run(){ // 覆写run()方法,作为线程 的操作主体
    for(int i=0;i<10;i++){
      System.out.println(name + "运行,i = " + i) ;
    }
  }
};
public class ThreadDemo02{
  public static void main(String args[]){
    MyThread mt1 = new MyThread("线程A ") ;  // 实例化对象
    MyThread mt2 = new MyThread("线程B ") ;  // 实例化对象
    mt1.start() ;  // 调用线程主体
    mt2.start() ;  // 调用线程主体
  }
};

程序运行结果:

从程序可以看出,现在的两个线程对象是交错运行的,哪个线程对象抢到了 CPU 资源,哪个线程就可以运行,所以程序每次的运行结果肯定是不一样的,在线程启动虽然调用的是 start() 方法,但实际上调用的却是 run() 方法定义的主体。

Thread 类和 Runnable 接口

通过 Thread 类和 Runable 接口都可以实现多线程,那么两者有哪些联系和区别呢?下面我们观察 Thread 类的定义。

public class Thread extends Object implements Runnable

从 Thread 类的定义可以清楚的发现,Thread 类也是 Runnable 接口的子类,但在Thread类中并没有完全实现 Runnable 接口中的 run() 方法,下面是 Thread 类的部分定义。

Private Runnable target;
public Thread(Runnable target,String name){
  init(null,target,name,0);
}
private void init(ThreadGroup g,Runnable target,String name,long stackSize){
  ...
  this.target=target;
}
public void run(){
  if(target!=null){
    target.run();
  }
}

从定义中可以发现,在 Thread 类中的 run() 方法调用的是 Runnable 接口中的 run() 方法,也就是说此方法是由 Runnable 子类完成的,所以如果要通过继承 Thread 类实现多线程,则必须覆写 run()。

实际上 Thread 类和 Runnable 接口之间在使用上也是有区别的,如果一个类继承 Thread类,则不适合于多个线程共享资源,而实现了 Runnable 接口,就可以方便的实现资源的共享。

线程的状态变化

要想实现多线程,必须在主线程中创建新的线程对象。任何线程一般具有5种状态,即创建,就绪,运行,阻塞,终止。下面分别介绍一下这几种状态:

1  创建状态

在程序中用构造方法创建了一个线程对象后,新的线程对象便处于新建状态,此时它已经有了相应的内存空间和其他资源,但还处于不可运行状态。新建一个线程对象可采用Thread 类的构造方法来实现,例如 “Thread thread=new Thread()”。

2  就绪状态

新建线程对象后,调用该线程的 start() 方法就可以启动线程。当线程启动时,线程进入就绪状态。此时,线程将进入线程队列排队,等待 CPU 服务,这表明它已经具备了运行条件。

3  运行状态

当就绪状态被调用并获得处理器资源时,线程就进入了运行状态。此时,自动调用该线程对象的 run() 方法。run() 方法定义该线程的操作和功能。

4  阻塞状态

一个正在执行的线程在某些特殊情况下,如被人为挂起或需要执行耗时的输入/输出操作,会让 CPU 暂时中止自己的执行,进入阻塞状态。在可执行状态下,如果调用sleep(),suspend(),wait() 等方法,线程都将进入阻塞状态,发生阻塞时线程不能进入排队队列,只有当引起阻塞的原因被消除后,线程才可以转入就绪状态。

5  死亡状态

线程调用 stop() 方法时或 run() 方法执行结束后,即处于死亡状态。处于死亡状态的线程不具有继续运行的能力。

在此提出一个问题,Java 程序每次运行至少启动几个线程?

回答:至少启动两个线程,每当使用 Java 命令执行一个类时,实际上都会启动一个 JVM,每一个JVM实际上就是在操作系统中启动一个线程,Java 本身具备了垃圾的收集机制。所以在 Java 运行时至少会启动两个线程,一个是 main 线程,另外一个是垃圾收集线程。

取得和设置线程的名称

class MyThread implements Runnable{ //实现Runnable接口
  public void run(){
    for(int i=0;i<3;i++){
      System.Out.Println(Thread.currentThread().getName()+"运行, i="+i); //取得当前线程的名称
    }
 }
};

public class ThreadDemo{
public static void main(String args[]){
  MyThread my=new MyThread(); //定义Runnable子类对象
  new Thread(my).start;  //系统自动设置线程名称
  new Thread(my,"线程A").start(); //手工设置线程名称
 }
};

程序运行结果:

线程的操作方法

刚才在分析自定义模式工作原理的时候其实就已经提到了,如果想要更改Glide的默认配

线程的强制运行

在线程操作中,可以使用 join() 方法让一个线程强制运行,线程强制运行期间,其他线程无法运行,必须等待此线程完成之后才可以继续执行。

class MyThread implements Runnable{ // 实现Runnable接口
  public void run(){ // 覆写run()方法
    for(int i=0;i<50;i++){
      System.out.println(Thread.currentThread().getName()
          + "运行,i = " + i) ; // 取得当前线程的名字
    }
  }
};
public class ThreadJoinDemo{
  public static void main(String args[]){
    MyThread mt = new MyThread() ; // 实例化Runnable子类对象
    Thread t = new Thread(mt,"线程");   // 实例化Thread对象
    t.start() ; // 启动线程
    for(int i=0;i<50;i++){
      if(i>10){
        try{
          t.join() ; // 线程强制运行
        }catch(InterruptedException e){
        }
      }
      System.out.println("Main线程运行 --> " + i) ;
    }
  }
};

程序运行结果:

线程的休眠

在程序中允许一个线程进行暂时的休眠,直接使用 Thread.sleep() 即可实现休眠。

class MyThread implements Runnable{ // 实现Runnable接口
  public void run(){ // 覆写run()方法
    for(int i=0;i<50;i++){
      try{
        Thread.sleep(500) ; // 线程休眠
      }catch(InterruptedException e){
      }
      System.out.println(Thread.currentThread().getName()
          + "运行,i = " + i) ; // 取得当前线程的名字
    }
  }
};
public class ThreadSleepDemo{
  public static void main(String args[]){
    MyThread mt = new MyThread() ; // 实例化Runnable子类对象
    Thread t = new Thread(mt,"线程");   // 实例化Thread对象
    t.start() ; // 启动线程
  }
};

程序运行结果:

中断线程

当一个线程运行时,另外一个线程可以直接通过interrupt()方法中断其运行状态。

class MyThread implements Runnable{ // 实现Runnable接口
  public void run(){ // 覆写run()方法
    System.out.println("1、进入run()方法") ;
    try{
      Thread.sleep(10000) ;  // 线程休眠10秒
      System.out.println("2、已经完成了休眠") ;
    }catch(InterruptedException e){
      System.out.println("3、休眠被终止") ;
      return ; // 返回调用处
    }
    System.out.println("4、run()方法正常结束") ;
  }
};
public class ThreadInterruptDemo{
  public static void main(String args[]){
    MyThread mt = new MyThread() ; // 实例化Runnable子类对象
    Thread t = new Thread(mt,"线程");   // 实例化Thread对象
    t.start() ; // 启动线程
    try{
      Thread.sleep(2000) ;  // 线程休眠2秒
    }catch(InterruptedException e){
      System.out.println("3、休眠被终止") ;
    }
    t.interrupt() ; // 中断线程执行
  }
};

程序运行结果:

后台线程

在 Java 程序中,只要前台有一个线程在运行,则整个 Java 进程都不会消失,所以此时可以设置一个后台线程,这样即使 Java 线程结束了,此后台线程依然会继续执行,要想实现这样的操作,直接使用 setDaemon() 方法即可。

class MyThread implements Runnable{ // 实现Runnable接口
  public void run(){ // 覆写run()方法
    while(true){
      System.out.println(Thread.currentThread().getName() + "在运行。") ;
    }
  }
};
public class ThreadDaemonDemo{
  public static void main(String args[]){
    MyThread mt = new MyThread() ; // 实例化Runnable子类对象
    Thread t = new Thread(mt,"线程");   // 实例化Thread对象
    t.setDaemon(true) ; // 此线程在后台运行
    t.start() ; // 启动线程
  }
};

在线程类 MyThread 中,尽管 run() 方法中是死循环的方式,但是程序依然可以执行完,因为方法中死循环的线程操作已经设置成后台运行。

线程的优先级

在 Java 的线程操作中,所有的线程在运行前都会保持在就绪状态,那么此时,哪个线程的优先级高,哪个线程就有可能会先被执行。

class MyThread implements Runnable{ // 实现Runnable接口
  public void run(){ // 覆写run()方法
    for(int i=0;i<5;i++){
      try{
        Thread.sleep(500) ; // 线程休眠
      }catch(InterruptedException e){
      }
      System.out.println(Thread.currentThread().getName()
          + "运行,i = " + i) ; // 取得当前线程的名字
    }
  }
};
public class ThreadPriorityDemo{
  public static void main(String args[]){
    Thread t1 = new Thread(new MyThread(),"线程A") ; // 实例化线程对象
    Thread t2 = new Thread(new MyThread(),"线程B") ; // 实例化线程对象
    Thread t3 = new Thread(new MyThread(),"线程C") ; // 实例化线程对象
    t1.setPriority(Thread.MIN_PRIORITY) ;  // 优先级最低
    t2.setPriority(Thread.MAX_PRIORITY) ;  // 优先级最高
    t3.setPriority(Thread.NORM_PRIORITY) ; // 优先级最中等
    t1.start() ;  // 启动线程
    t2.start() ;  // 启动线程
    t3.start() ;  // 启动线程
  }
};

从程序的运行结果中可以观察到,线程将根据其优先级的大小来决定哪个线程会先运行,但是需要注意并非优先级越高就一定会先执行,哪个线程先执行将由 CPU 的调度决定。

线程的礼让

在线程操作中,也可以使用 yield() 方法将一个线程的操作暂时让给其他线程执行

class MyThread implements Runnable{ // 实现Runnable接口
  public void run(){ // 覆写run()方法
    for(int i=0;i<5;i++){
      try{
        Thread.sleep(500) ;
      }catch(Exception e){
      }
      System.out.println(Thread.currentThread().getName()
          + "运行,i = " + i) ; // 取得当前线程的名字
      if(i==2){
        System.out.print("线程礼让:") ;
        Thread.currentThread().yield() ;  // 线程礼让
      }
    }
  }
};
public class ThreadYieldDemo{
  public static void main(String args[]){
    MyThread my = new MyThread() ; // 实例化MyThread对象
    Thread t1 = new Thread(my,"线程A") ;
    Thread t2 = new Thread(my,"线程B") ;
    t1.start() ;
    t2.start() ;
  }
};

程序运行结果

同步以及死锁

一个多线程的程序如果是通过 Runnable 接口实现的,则意味着类中的属性被多个线程共享,那么这样就会造成一种问题,如果这多个线程要操作同一个资源时就有可能出现资源同步问题。

解决方法:

同步代码块

synchronized(同步对象){
 需要同步的代码
 }
class MyThread implements Runnable{
  private int ticket = 5 ;  // 假设一共有5张票
  public void run(){
    for(int i=0;i<100;i++){
      synchronized(this){ // 要对当前对象进行同步
        if(ticket>0){  // 还有票
          try{
            Thread.sleep(300) ; // 加入延迟
          }catch(InterruptedException e){
            e.printStackTrace() ;
          }
          System.out.println("卖票:ticket = " + ticket-- );
        }
      }
    }
  }
};
public class SyncDemo02{
  public static void main(String args[]){
    MyThread mt = new MyThread() ; // 定义线程对象
    Thread t1 = new Thread(mt) ;  // 定义Thread对象
    Thread t2 = new Thread(mt) ;  // 定义Thread对象
    Thread t3 = new Thread(mt) ;  // 定义Thread对象
    t1.start() ;
    t2.start() ;
    t3.start() ;
  }
};

程序运行结果:

同步方法

除了可以将需要的代码设置成同步代码块外,也可以使用 synchronized 关键字将一个方法声明为同步方法。

synchronized 方法返回值 方法名称(参数列表){ 

 }
class MyThread implements Runnable{
  private int ticket = 5 ;  // 假设一共有5张票
  public void run(){
    for(int i=0;i<100;i++){
      this.sale() ;  // 调用同步方法
    }
  }
  public synchronized void sale(){  // 声明同步方法
    if(ticket>0){  // 还有票
      try{
        Thread.sleep(300) ; // 加入延迟
      }catch(InterruptedException e){
        e.printStackTrace() ;
      }
      System.out.println("卖票:ticket = " + ticket-- );
    }

  }
};
public class SyncDemo03{
  public static void main(String args[]){
    MyThread mt = new MyThread() ; // 定义线程对象
    Thread t1 = new Thread(mt) ;  // 定义Thread对象
    Thread t2 = new Thread(mt) ;  // 定义Thread对象
    Thread t3 = new Thread(mt) ;  // 定义Thread对象
    t1.start() ;
    t2.start() ;
    t3.start() ;
  }
};

程序运行结果

从程序运行的结果可以发现,此代码完成了与之前同步代码同样的功能。

死锁

同步可以保证资源共享操作的正确性,但是过多同步也会产生问题。例如,现在张三想要李四的画,李四想要张三的书,张三对李四说“把你的画给我,我就给你书”,李四也对张三说“把你的书给我,我就给你画”两个人互相等对方先行动,就这么干等没有结果,这实际上就是死锁的概念。

所谓死锁,就是两个线程都在等待对方先完成,造成程序的停滞,一般程序的死锁都是在程序运行时出现的。

下面以一个简单范例说明这个概念

class Zhangsan{ // 定义张三类
  public void say(){
    System.out.println("张三对李四说:“你给我画,我就把书给你。”") ;
  }
  public void get(){
    System.out.println("张三得到画了。") ;
  }
};
class Lisi{ // 定义李四类
  public void say(){
    System.out.println("李四对张三说:“你给我书,我就把画给你”") ;
  }
  public void get(){
    System.out.println("李四得到书了。") ;
  }
};
public class ThreadDeadLock implements Runnable{
  private static Zhangsan zs = new Zhangsan() ;    // 实例化static型对象
  private static Lisi ls = new Lisi() ;    // 实例化static型对象
  private boolean flag = false ; // 声明标志位,判断那个先说话
  public void run(){ // 覆写run()方法
    if(flag){
      synchronized(zs){  // 同步张三
        zs.say() ;
        try{
          Thread.sleep(500) ;
        }catch(InterruptedException e){
          e.printStackTrace() ;
        }
        synchronized(ls){
          zs.get() ;
        }
      }
    }else{
      synchronized(ls){
        ls.say() ;
        try{
          Thread.sleep(500) ;
        }catch(InterruptedException e){
          e.printStackTrace() ;
        }
        synchronized(zs){
          ls.get() ;
        }
      }
    }
  }
  public static void main(String args[]){
    ThreadDeadLock t1 = new ThreadDeadLock() ;   // 控制张三
    ThreadDeadLock t2 = new ThreadDeadLock() ;   // 控制李四
    t1.flag = true ;
    t2.flag = false ;
    Thread thA = new Thread(t1) ;
    Thread thB = new Thread(t2) ;
    thA.start() ;
    thB.start() ;
  }
};

程序运行结果

以下代码不再执行,程序进入死锁状态。

总结

至此关于多线程一些基本操作就介绍完了,鉴于笔者经验有限,如果有什么不足和缺漏的地方,欢迎相互交流学习,感谢大家!

以上就是实例代码讲解JAVA多线程的详细内容,更多关于JAVA多线程的资料请关注我们其它相关文章!

(0)

相关推荐

  • java多线程volatile内存语义解析

    这篇文章主要介绍了java多线程volatile内存语义解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 volatile关键字是java虚拟机提供的最轻量级额的同步机制.由于volatile关键字与java内存模型相关,因此,我们在介绍volatile关键字之前,对java内存模型进行更多的补充(之前的博文也曾介绍过). 1. java内存模型(JMM) JMM是一种规范,主要用于定义共享变量的访问规则,目的是解决多个线程本地内存与共享内存

  • Java多线程生产者消费者模式实现过程解析

    单生产者与单消费者 示例: public class ProduceConsume { public static void main(String[] args) { String lock = new String(""); Produce produce = new Produce(lock); Consume consume = new Consume(lock); new Thread(() -> { while (true) { produce.setValue();

  • Java模拟多线程实现抢票代码实例

    这篇文章主要介绍了Java模拟多线程实现抢票,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 实现100张票抢购的demo 这里需要一个变量,来保存100张 局部变量: 定义在方法内,方法运行存在,方法运行结束销毁,无法保存一个持久化数据!!! 成员变量: 保存在类对象内,创建对象之后存在,对象不销毁成员变量也不会被内存收回.因为 在每一个类对象中,都存在一个对应的成员变量,这些成员变量不是同一个数据.不是 共享资源,不合适!!! 静态成员变量:

  • Java多线程的临界资源问题解决方案

    这篇文章主要介绍了Java多线程的临界资源问题解决方案,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 临界资源问题的原因:某一个线程在对临界资源进行访问时,还没来得及完全修改临界资源的值,临界资源就被其他线程拿去访问,导致多个线程访问同一资源.直观表现为打印结果顺序混乱. 解决方法:加锁 静态方法中用类锁,非静态方法中用对象锁. 1.同步代码段:synchronized(){...} 2.同步方法:使用关键字synchronized修饰的方法

  • Java多线程模拟电影售票过程

    用多线程模拟电影售票过程(Java实训) 实训目的: 多线程的实现.线程同步 实训要求: 总票数和售票窗口数由键盘输入,用每个线程处理一个窗口的售票. Test.java package program5; import java.util.Scanner; public class Test { public static void main(String[] args) { // TODO Auto-generated method stub Scanner sc=new Scanner(S

  • Java多线程文件分片下载实现的示例代码

    多线程下载介绍 多线程下载技术是很常见的一种下载方案,这种方式充分利用了多线程的优势,在同一时间段内通过多个线程发起下载请求,将需要下载的数据分割成多个部分,每一个线程只负责下载其中一个部分,然后将下载后的数据组装成完整的数据文件,这样便大大加快了下载效率.常见的下载器,迅雷,QQ旋风等都采用了这种技术. 分片下载 所谓分片下载就是要利用多线程的优势,将要下载的文件一块一块的分配到各个线程中去下载,这样就极大的提高了下载速度. 技术难点 并不能说是什么难点,只能说没接触过不知道罢了. 1.如何请

  • JAVA模拟多线程给多用户发送短信

    这篇文章主要介绍了JAVA模拟多线程给多用户发送短信,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 代码编写逻辑,假设需要给11个用户发送短信,每一个线程给两个用户发送短信,实现多线程的并发处理 创建实体user package www.it.com.test; /** * @author wangjie * @date 2019/11/20 17:10 * @description * @company 石文软件有限公司 */ public

  • 基于Java实现多线程下载并允许断点续传

    完整代码:https://github.com/iyuanyb/Downloader 多线程下载及断点续传的实现是使用 HTTP/1.1 引入的 Range 请求参数,可以访问Web资源的指定区间的内容.虽然实现了多线程及断点续传,但还有很多不完善的地方. 包含四个类: Downloader: 主类,负责分配任务给各个子线程,及检测进度DownloadFile: 表示要下载的哪个文件,为了能写输入到文件的指定位置,使用 RandomAccessFile 类操作文件,多个线程写同一个文件需要保证线

  • 实例代码讲解JAVA多线程

    进程与线程 进程是程序的一次动态执行过程,它需要经历从代码加载,代码执行到执行完毕的一个完整的过程,这个过程也是进程本身从产生,发展到最终消亡的过程.多进程操作系统能同时达运行多个进程(程序),由于 CPU 具备分时机制,所以每个进程都能循环获得自己的CPU 时间片.由于 CPU 执行速度非常快,使得所有程序好像是在同时运行一样. 多线程是实现并发机制的一种有效手段.进程和线程一样,都是实现并发的一个基本单位.线程是比进程更小的执行单位,线程是进程的基础之上进行进一步的划分.所谓多线程是指一个进

  • 实例代码讲解JAVA 观察者模式

    当对象间存在一对多关系时,则使用观察者模式(Observer Pattern).比如,当一个对象被修改时,则会自动通知依赖它的对象.观察者模式属于行为型模式. 介绍 意图:定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都得到通知并被自动更新. 主要解决:一个对象状态改变给其他对象通知的问题,而且要考虑到易用和低耦合,保证高度的协作. 何时使用:一个对象(目标对象)的状态发生改变,所有的依赖对象(观察者对象)都将得到通知,进行广播通知. 如何解决:使用面向对象技术

  • Spring boot + mybatis + orcale实现步骤实例代码讲解

    接着上次的实现, 添加 mybatis 查询 orcale 数据库 第一步: 新建几个必须的包, 结果如下 第二步: 在service包下新建personService.java 根据名字查person方法接口 package com.example.first.service; import com.example.first.entity.Person; public interface personService { Person queryPersonByName(String name

  • 实例代码讲解Python 线程池

    大家都知道当任务过多,任务量过大时如果想提高效率的一个最简单的方法就是用多线程去处理,比如爬取上万个网页中的特定数据,以及将爬取数据和清洗数据的工作交给不同的线程去处理,也就是生产者消费者模式,都是典型的多线程使用场景. 那是不是意味着线程数量越多,程序的执行效率就越快呢. 显然不是.线程也是一个对象,是需要占用资源的,线程数量过多的话肯定会消耗过多的资源,同时线程间的上下文切换也是一笔不小的开销,所以有时候开辟过多的线程不但不会提高程序的执行效率,反而会适得其反使程序变慢,得不偿失. 所以,如

  • ASP.NET操作MySql数据库的实例代码讲解

    一.把MySql.Data.dll放到BIN目录下. 二.这是aspx.cs的全部源码,修改参数直接运行即可!   using MySql.Data.MySqlClient; using System; using System.Collections.Generic; using System.Data; using System.Linq; using System.Web; using System.Web.UI; using System.Web.UI.WebControls; publ

  • jQuery判断邮箱格式对错实例代码讲解

    废话不多说了,具体代码如下所示: <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>检测Email地址格式是否正确</title> <script src="http://apps.bdimg.com/libs/jquery/1.10.2/jquery.min.js"><

  • JS实现JSON.stringify的实例代码讲解

    JSON.stringify是浏览器高版本带的一个将JS的Objtect对象转换为JSON字符串的一个方法,不过再IE6下面,并不存在JSON这一对象,因此,用到此方法时,需要写一套兼容性的代码. JSON.stringify的一些规则以及注意点:当对象为数字,null,boolean的时候,直接转换为相应的字符串就可以了. 但是string,function,undefined,object,array等,需要特殊处理. 1.undefined,该类型使用JSON.stringify处理的时候

  • Android Dialog对话框实例代码讲解

    Dialog的基本方法 //创建Dialog AlertDialog.Builder builder = new AlertDialog.Builder(MainActivity.this); //设置标题图标 builder.setIcon(R.drawable.ic_launcher); //设置标题 builder.setTitle("这是一个对话框"); //设置信息 builder.setMessage("是否要跳转?"); //确定按钮 setPosit

  • vue slot与传参实例代码讲解

    插槽分为默认插槽和具名插槽: 默认插槽: //父组件 <div> <h3>父组件</h3> <testChild> <div>默认插槽</div> </testChild> </div> //子组件 <div> <h4>子组件</h4> <slot></slot> </div> 具名插槽: 注意:具名插槽需要包裹在  template  标

  • 实例代码讲解c# 线程(下)

    前言 实例代码讲解c# 线程(上) 使用Mutex类 class Program { static void Main(string[] args) { const string MutexName ="CSharpThreadingCookbook"; using (var m = new Mutex(false, MutexName)) { if (!m.WaitOne(TimeSpan.FromSeconds(5), false)) { Console.WriteLine(&qu

随机推荐