java-多线程操作全(Thread)-Timer简单使用

 一、 多线程概念和作用

 线程指进程中的一个执行场景，也就是执行流程，那么进程和线程的区别是什么

  1.每个进程是一个应用程序，都有独立的内存空间

  2.同一个进程中的线程共享其进程中的内存和资源

  (共享的内存是堆内存和方法内存，栈内存不共享，每个线程有自己的堆内存)

 进程：进程对应一个应用程序

  现在的计算机都是支持多进程的，在同一个操作系统中，可以同时启动多个进程 

  

 多进程的作用：

 * 单进程只能做一件事 : 一边玩游戏，一边听音乐不是同时运行，而是进程之间的频繁调度，切换速度极高，感觉是同时进行。

 * 多线程的作用不是提高执行速度，而是提高CPU的使用率。进程和进程之间的内存是独立的、

 * 线程：是进程中的执行场景。一个进程可以启动多个线程。

 * 多线程的作用：不是为了提高执行速度，而是为了提高应用程序的使用率

 

 * java程序的运行原理

 * java命令启动java虚拟机，启动JVM，等于启动一个应用程序，表明启动一个进程。该进程会自动启动一个“主线程”，然后主线程去调用某各类的main方法。

 * 所以，main方法运行在主线程中。在此之前的所有程序都是单线程的。

 

 二、线程的创建和启动

 

 *Java虚拟机的主线程入口是main方法，用户可以自己创建线程，创建方式有两种

 *1.继承Thread类

 *2.实现Runnable接口(推荐使用Runnable)

 

 *继承Thread类

 *采用 Thread类创建线程,用户只需要继承 Thread,覆盖 Thread中的run方法,父类 Thread中的run方法没有抛出异常,那么子类也不角能抛出异常,最后采用start启动线程即可

 

 实现Runnable接口

 Thread对象本身就实现了 Runnable接口,但一般建议直接使用 Runnable接口来写多线程程序,因为接口会比类带来更多的好处

 

三、java语言中实现多线程第一种方式

 

1.继承java.lang.Thread

2.重写run方法

三个知识点 ：定义线程 、创建线程、 启动线程

package com.steven.demo;

import java.lang.Thread;
public class ThreadTest {
  public static void main(String[] args) {

    Thread thread = new Student();
    //启动线程
    thread.start();//打印Run:0~9
    //start方法执行完瞬间结束，告诉JVM再分配一个新的线程 给t线程
    //是随机分配的，没有规律
    
    //run不需要手动调用，系统程序启动之后会自动调用方法
    //thread.run();//这是普通方法的调用，这样做程序只有一个线程，run方法结束之后，下边的程序才会执行
    
    for (int i = 0; i < 5; i++) {
        System.out.println("main"+i);
    }
    //有了多线程之后，main方法结束只是主线程中没有方法栈帧了 但是其他线程或者其他栈中还有栈帧  main方法结束，程序可能还在运行
  }
}

class Student extends Thread {
    //重写Run方法
    public void run() {
       for (int i = 0; i < 10; i++) {
        System.out.println("Run:"+i);
       }
    }
}

四、java语言中实现多线程第二种方式

1.写一个类实现

2.重写run方法

 

package com.steven.demo;

import java.lang.Runnable;
import java.lang.Thread;
public class ThreadTest02 {
   public static void main(String[] args) {
    //创建线程:
    Thread thread = new Thread(new Teacher());
    //启动线程
    thread.start();
   }
}
class Teacher implements Runnable {
    //重写Run方法
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("Run:"+i);
        }
    }
}

五、掌握线程方法：

1.获取当前线程的对象 Thread.currentThread()

2.给线程起名t.setName()

3.获取线程的名字:t.getName()

 

package com.steven.demo;
public class ThreadTest03 {
  public static void main(String[] args) {
    
      //获取当前线程的对象 main主线程
      Thread thread = Thread.currentThread();
      //获取当前线程的名字
      System.out.println("当前名称的名称"+thread.getName());//当前名称的名称main
      
      Thread t1 = new Thread(new ArrayTest());
      //给线程起名
      t1.setName("Steven");
      t1.start();//线程的名称Steven
      
      Thread thread2 = new Thread(new ArrayTest());
      //给线程重命名
      thread2.setName("珂珂");
      thread2.start();//线程的名称珂珂
  }
}
class ArrayTest implements Runnable {
    public void run() {
        Thread thread = Thread.currentThread();//获取当前线程的对象
        System.out.println("线程的名称"+thread.getName());
    }
}

六、线程的优先级

优先级高的获取CPU时间片，相对多一些

最高：10

最小：1

默认：5

优先级1-10

优先级高的线程，会得到CPU的时间多一些，优先执行完成

 

public class ThreadTest04 {
  public static void main(String[] args) {
    System.out.println("最高"+Thread.MAX_PRIORITY);
    System.out.println("最小"+Thread.MIN_PRIORITY);
    System.out.println("默认"+Thread.NORM_PRIORITY);
    
    Thread t1 = new Thread(new KeKe());
    t1.setName("t1");
    
    Thread t2 = new Thread(new KeKe());
    t2.setName("t2");
    
    //获取线程的优先级
    System.out.println("t1优先级"+t1.getPriority());
    System.out.println("t2优先级"+t2.getPriority());
    
    //设置优先级
    t1.setPriority(5);
    t2.setPriority(6);
    
    //启动
    t1.start();
    t2.start();//线程虽然有优先级，但是随机分配的，打印结果不一致
  }
}
class KeKe extends Thread {
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+"----------------"+i);
        }
    }
}

七、线程休眠

①Thread.sleep()使当前正在执行的线程执行休眠操作(暂停执行) 单位：毫秒

sleep 静态方法 作用: 阻塞当前线程，腾出CPU，让给其他线程

public class ThreadTest05 {

    public static void main(String[] args) {
        Thread thread = new Array1();
        thread.setName("thread1");
        thread.start();
        //获取当前线程的对象 main主线程
          Thread t = Thread.currentThread();
          //获取当前线程的名字
          System.out.println("当前名称的名称"+t.getName());//当前名称的名称main    
          
          //阻塞主线程
          for (int i = 0; i < 10; i++) {
              System.out.println(Thread.currentThread().getName() + "-------------------:" + i);
                try {
                    Thread.sleep(2000);//程序休眠2秒钟
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
        }
    }
}
class Array1 extends Thread {

    public void run() {
        System.out.println("线程正在启动=-====");
        for (int i = 0 ; i < 5 ; i ++) {
            System.out.println(Thread.currentThread().getName() + "-------------------:" + i);
            try {
                Thread.sleep(2000);//程序休眠2秒钟
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
}

②Thread.yield()暂停当前正在执行的线程对象，并执行其他线程。

 1.静态方法

 2.作用：给同一个优先级的线程让位，但是让位时间不固定

 3.和sleep方法相同，就是yield的时间不固定

 他与sleep类似，只是不能由用户执行暂停时间，并且yield()只能让同优先级的线程有执行的机会

 

package com.steven.demo;
public class ThreadTest07 {
  public static void main(String[] args) {
      //1.创建线程
       Thread thread = new HThread();
       thread.setName("线程07");
       //2.启动线程
       thread.start();
       //3.主线程
       for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() +"---------:"+i);
        }
       System.out.println("Steven=====");
  }
}
class HThread extends Thread {
    
    public void run() {
        
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() +"---------:"+i);
            if (i % 2 == 0) {
                //暂定当前线程，执行其他线程
                Thread.yield();
            }
        }
    }
}

③线程的基本操作

/*
 线程的基本操作：创建，启动，休眠，异常处理
 */
public class ThreadTest06 {
    
   public static void main(String[] args) {
       try {
         //1.创建线程
           Thread thread = new MyThread();
           thread.setName("线程");
           //2.启动线程
           thread.start();
           //3.休眠
           Thread.sleep(2000);
           System.out.println("Steven=====");
       }catch (InterruptedException e) {
           e.printStackTrace();
       }   
   }
}

class MyThread extends Thread {
    
    public void run() {
        for (int i = 0; i < 10; i++) {
            
            try {
                Thread.sleep(3000);
            } catch (Exception e) {
                e.printStackTrace();
            }
            
            System.out.println(Thread.currentThread().getName() +"---------:"+i);
        }
    }
}

八、线程的合并(join)

public class ThreadTest08 {
   public static void main(String[] args) {
     
   try {
     //1.创建线程
       Thread thread = new KThread();
       thread.setName("线程07");
       //2.启动线程
       thread.start();
       //3.合并线程 (线程07和main线程合并)
       thread.join();//输出只保证一个线程正在执行，依次执行，单线程的程序 (先执行线程07后执行main)
      //主线程
       for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() +"---------:"+i);
        } 
       //当前线程可以调用第一个线程的join方法，调用后当前线程会被阻塞不再执行，直到被调用的线程执行完毕，当前线程才会执行
    } catch (InterruptedException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
   }
}
class KThread extends Thread {
    
    public void run() {
        
        for (int i = 0; i < 10; i++) {
            try {
                Thread.sleep(2000);
                System.out.println(Thread.currentThread().getName() +"---------:"+i);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            };
            
        }
    }
}

九、线程同步案例

<1>模拟取款：（不使用同步机制）多线程同时对同一个账号进行取款操作

 

/*
模拟取款：不使用同步机制，多线程同时对同一个账号进行取款操作
thread 和 thread2
异步编程模型：thread线程执行的是thread , thread2线程执行的是thread2 ,两个线程之间谁也不等于谁
同步编程模型：thread线程和thread2线程执行，当thread线程必须等thread2的线程的执行结果之后，thread线程才能执行 ，这是同步编程

什么时候需要引入同步：
1.为了数据安全，尽管程序的使用率低，但是为了保证数据安全性，必须得加入线程同步机制, 线程同步机制 使程序变成了单线程(一个线程)
2.在什么条件下需要使用线程同步
<1>必须是多线程环境
<2>多线程环境在共享同一个数据时
<3>共享的数据涉及到修改操作
 */
package com.steven.demo;

public class ThreadTest09 {
   public static void main(String[] args) {
     //创建一个公共的账户
    Account account = new Account("steven_kou",10000.0);
    
    //创建线程对同一个账户进行取款
    Thread thread = new Thread(new Money(account));
    thread.setName("steven");
    Thread thread2 = new Thread(new Money(account));
    thread2.setName("kou");
    
    thread.start();
    thread2.start();
   }
}

//取款线程
class Money implements Runnable {

    //账户
    Account account;
    
    Money (Account account){
        this.account = account;
    }
    
    public void run() {
        account.withDraw(2000.0);
        System.out.println("取款2000.0$，余额为："+account.getBalance());//取款2000.0$，余额为：8000.0 (输出两次)
    }
    
}

//银行账户
class Account {
    
    private String actno;
    private double balance;//账户余额
    
    public Account() {}
    public Account(String actno,double balance) {
        this.actno = actno;//成员变量|局部变量
        this.balance = balance;
    }
    
    public void setActno(String actno) {
        this.actno = actno;
    }
    
    public String getActno() {
        return actno;
    }
    
    public void setBalance(double balance) {
        this.balance = balance;
    }
    
    public double getBalance() {
        return balance;
    }
    
    //对外提供一个取款方法
    public void withDraw(double money) {
        //对账户进行取款操作
        double after = balance - money;
        //延迟操作
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();//InterruptedException 线程中断下抛出的异常
        }
        this.setBalance(after);//更新账户余额，重新赋值
    }
}

<2>模拟取款（同步机制，同步锁synchronized）

①以下程序使用线程同步机制保证数据安全

 

package com.steven.demo;
public class ThreadTest09 {
   public static void main(String[] args) {
     //创建一个公共的账户
    Account account = new Account("steven_kou",10000.0);
    
    //创建线程对同一个账户进行取款
    Thread thread = new Thread(new Money(account));
    thread.setName("steven");
    Thread thread2 = new Thread(new Money(account));
    thread2.setName("kou");
    
    thread.start();
    thread2.start();
   }
}

//取款线程
class Money implements Runnable {

    //账户
    Account account;
    
    Money (Account account){
        this.account = account;
    }
    
    public void run() {
        account.withDraw(2000.0);
        System.out.println("取款2000.0$，余额为："+account.getBalance());//取款2000.0$，余额为：8000.0 (输出两次)
    }
    
}

//银行账户
class Account {
    
    private String actno;
    private double balance;//账户余额
    
    public Account() {}
    public Account(String actno,double balance) {
        this.actno = actno;//成员变量|局部变量
        this.balance = balance;
    }
    
    public void setActno(String actno) {
        this.actno = actno;
    }
    
    public String getActno() {
        return actno;
    }
    
    public void setBalance(double balance) {
        this.balance = balance;
    }
    
    public double getBalance() {
        return balance;
    }
    
    //对外提供一个取款方法
        //TODO 取款 同步
        public void withDraw(double money) {
            /*
             需要把同步的代码，放到同步的语句块中
             thread线程执行到此处，遇到了synchronized 关键字，就会去找this的对象锁 如果找到了this的对象锁，则进入同步语句块 执行程序
             当同步语句块代码执行结束的时候，thread线程归还this的对象锁
             
              在thread线程执行同步语句块的过程中，如果thread2线程也执行以下代码。遇到synchronized 关键字，所以去找this对象锁，但是该对象被thread线程持有, 只能等待thread线程使用完以后再解锁this对象锁
             */
            
            //同步锁
            synchronized (this) {
                //对账户进行取款操作
                double after = balance - money;
                //延迟操作
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();//InterruptedException 线程中断下抛出的异常
                }
                //更新账户余额，重新赋值
                this.setBalance(after);
            }
        }
}

②synchronized关键字 添加到成员方法上，线程拿走的也是this对象锁

//对外提供一个取款方法
    //TODO 取款 同步
    //synchronized关键字 添加到成员方法上，线程拿走的也是this对象锁
    public synchronized void withDraw(double money) {
        /*
         需要把同步的代码，放到同步的语句块中
         thread线程执行到此处，遇到了synchronized 关键字，就会去找this的对象锁 如果找到了this的对象锁，则进入同步语句块 执行程序
         当同步语句块代码执行结束的时候，thread线程归还this的对象锁
         
         在thread线程执行同步语句块的过程中，如果thread2线程也执行以下代码。遇到synchronized 关键字，所以去找this对象锁，但是该对象被thread线程持有, 只能等待thread线程使用完以后再解锁this对象锁
         */
        
        //同步锁
//            synchronized (this) {
            //对账户进行取款操作
            double after = balance - money;
            //延迟操作
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();//InterruptedException 线程中断下抛出的异常
            }
            //更新账户余额，重新赋值
            this.setBalance(after);
//            }
    }

三、守护线程

①定义一个用户线程

package com.steven.demo;

//定义一个用户线程
public class UserThread01 {
   public static void main(String[] args) {
     Runnable runnable = new UserTest();
     Thread thread = new Thread(runnable, "UserThread");
     thread.start();
     for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + "==== " + i);
        }
     System.out.println("主线程结束---");
  }
}

class UserTest implements Runnable {
    
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + "==== " + i);
        }
        
    }
}

②改为守护线程

package com.steven.demo;
//守护线程
//其他所有的用户线程结束，则守护线程退出
//守护线程一般都是无限执行的 守护线程最后结束(先执行用户线程)
//设置守护线程以后，当前主线程结束后，守护线程并没有把所有的数据输出就结束 也就是说 守护线程是为用户线程服务的，当用户线程全部结束，守护线程会自动化结束

public class UserThread02 {
    public static void main(String[] args) {
        Thread thread = new UserTest02();
        thread.setName("thread");
        //将thread这个用户线程 修改为守护线程
        thread.setDaemon(true);
        thread.start();
        //主线程 
         for (int i = 0; i < 10; i++) {
                System.out.println(Thread.currentThread().getName() + "==== " + i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
         System.out.println("主线程结束---");
    }
}
class UserTest02 extends Thread {
    public void run() {
        int i = 0;
        while (true) {
            i ++;
            System.out.println(Thread.currentThread().getName() +"====:"+i);
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

四、定时器简单使用：

 

package com.steven.demo;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;

/*
 Timer 定时器
 */
public class TimerTest01 {
    
   public static void main(String[] args) {
    System.out.println("来了");   
    Timer timer = new Timer();
    try {
          Date date = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse("2018-10-07 19:26:02");
          //安排在指定的时间执行指定的任务
          timer.schedule(new MyTimer(), date,1000*60*60*24);//date执行后续任务的时间间隔   设置定时任务：在2018-10-07 19:26:02执行此任务, 24小时执行一次
          //timer.schedule(new MyTimer(), date,1000*2);
          //如果设置每天执行一次：Date date = new SimpleDateFormat("HH:mm:ss").parse("19:26:02");
          
    }catch (ParseException e) {
        e.printStackTrace();
    } catch (NullPointerException e) {
        e.printStackTrace();
    } catch (IllegalArgumentException e) {
        e.printStackTrace();
    } catch (IllegalStateException e) {
        e.printStackTrace();
    }
      
   }
}

class MyTimer extends TimerTask {

    public void run() {
        System.out.println("=="+new Date());//==Sun Oct 07 19:26:02 CST 2018
    }
    
}