Java 线程

Juyy_Code

已于 2022-07-06 19:18:11 修改

阅读量102

点赞数

文章标签： java jvm 开发语言

于 2022-07-05 19:37:19 首次发布

本文链接：https://blog.youkuaiyun.com/m0_47005019/article/details/125625787

版权

##线程:
        一个顺序的单一的程序执行流程就是一个线程。代码一句一句的有先后顺序的执行。
##多线程:
        多个单一顺序执行的流程并发运行。造成"感官上同时运行"的效果。
##并发:
        多个线程实际运行是走走停停的。线程调度程序会将CPU运行时间划分为若干个时间片段并尽可能均匀的分配给每个线程，拿到时间片的线程被CPU执行这段时间。当超时后线程调度程序会再次分配一个时间片段给一个线程使得CPU执行它。如此反复。由于CPU执行时间在纳秒级别，我们感觉不到切换线程运行的过程。所以微观上走走停停，宏观上感觉一起运行的现象成为并发运行!

第一种创建线程的方式
优点:
在于结构简单，便于匿名内部类形式创建。
缺点:
1:直接继承线程，会导致不能在继承其他类去复用方法，这在实际开发中是非常不便的。
2:定义线程的同时重写了run方法，会导致线程与线程任务绑定在了一起，不利于线程的重用。
/**
   线程的启动
*/
public class ThreadDemo1 {
  public static void main(String[] args) {
     //创建两个线程
     Thread t1 = new MyThread1();
     Thread t2 = new MyThread2();
     
     t1.start();
     t2.start();
  }
}

方式二:实现Runnable接口单独定义线程任务

/**
 * 第二种创建线程的方式
 * 实现Runnable接口单独定义线程任务
 */
public class ThreadDemo2 {
    public static void main(String[] args) {
       //实例化任务
       Runnable r1 = new MyRunnable1();
       Runnable r2 = new MyRunnable2();
       //创建线程并指派任务
       Thread t1 = new Thread(r1);
       Thread t2 = new Thread(r2);

       t1.start();
       t2.start();
    }
}
class MyRunnable1 implements Runnable{
   public void run() {
       for (int i=0;i<1000;i++){
           System.out.println("你是谁啊?");
       }
   }
}
class MyRunnable2 implements Runnable{
   public void run() {
       for (int i=0;i<1000;i++){
          System.out.println("开门!查水表的!");
       }
   }
}
--------------------------------------------------------------------
/*
匿名内部类形式创建线程
*/
Thread t1 = new Thread(){
   public void run(){
       for(int i=0;i<1000;i++){
            System.out.println("你是谁啊?");
            }
        }
    };

  //Runnable可以使用lambda表达式创建
  Runnable r2 = ()->{
       for(int i=0;i<1000;i++){
           System.out.println("我是查水表的!");
        }
   };

##主线程
java中的代码都是靠线程运行的，执行main方法的线程称为"主线程"。

public class CurrentThreadDemo {
    public static void main(String[] args) {
    /*
       后期会学习到一个很重要的API:ThreadLocal,它可以使得我们在一个线程上跨越多个
       方法时共享数据使用，其内部要用到currentThread方法来辨别线程。
       如spring的事物控制就是靠ThreadLocal实现的。
     */
    Thread main = Thread.currentThread();//获取执行main方法的线程(主线程)
    System.out.println("线程:"+main);

    dosome();//主线程执行dosome方法
  }
    public static void dosome(){
       Thread t = Thread.currentThread();//获取执行dosome方法的线程
       System.out.println("执行dosome方法的线程是:"+t);
  }
}

使用多线程实现多客户端连接服务端

/**
 * 聊天室服务端
 */
public class Server {
    /**
     * 运行在服务端的ServerSocket主要完成两个工作:
     * 1:向服务端操作系统申请服务端口，客户端就是通过这个端口与ServerSocket建立链接
     * 2:监听端口，一旦一个客户端建立链接，会立即返回一个Socket。通过这个Socket
     *   就可以和该客户端交互了
     *
     * 我们可以把ServerSocket想象成某客服的"总机"。用户打电话到总机，总机分配一个
     * 电话使得服务端与你沟通。
     */
    private ServerSocket serverSocket;

    /**
     * 服务端构造方法，用来初始化
     */
    public Server(){
        try {
            System.out.println("正在启动服务端...");
            /*
               实例化ServerSocket时要指定服务端口，该端口不能与操作系统其他
               应用程序占用的端口相同，否则会抛出异常:
               java.net.BindException:address already in use

               端口是一个数字，取值范围:0-65535之间。
               6000之前的的端口不要使用，密集绑定系统应用和流行应用程序。
             */
            serverSocket = new ServerSocket(8088);
            System.out.println("服务端启动完毕!");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 服务端开始工作的方法
     */
    public void start(){
    try {
         while(true) {
         System.out.println("等待客户端链接...");
    /*
         ServerSocket提供了接受客户端链接的方法:
         Socket accept()
         这个方法是一个阻塞方法，调用后方法"卡住"，此时开始等待客户端
         的链接，直到一个客户端链接，此时该方法会立即返回一个Socket实例
         通过这个Socket就可以与客户端进行交互了。

         可以理解为此操作是接电话，电话没响时就一直等。
    */
         Socket socket = serverSocket.accept();
         System.out.println("一个客户端链接了！");
        //启动一个线程与该客户端交互
         ClientHandler clientHandler = new ClientHandler(socket);
         Thread t = new Thread(clientHandler);
         t.start();

            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        Server server = new Server();
        server.start();
    }

    /**
     * 定义线程任务
     * 目的是让一个线程完成与特定客户端的交互工作
     */
    private class ClientHandler implements Runnable{
        private Socket socket;
        public ClientHandler(Socket socket){
            this.socket = socket;
        }
        public void run(){
     try{
         /*
            Socket提供的方法:
            InputStream getInputStream()
            获取的字节输入流读取的是对方计算机发送过来的字节
         */
          InputStream in = socket.getInputStream();
          InputStreamReader isr = new InputStreamReader(in, "UTF-8");
          BufferedReader br = new BufferedReader(isr);

          String message = null;
          while ((message = br.readLine()) != null) {
               System.out.println("客户端说:" + message);
              }
          }catch(IOException e){
               e.printStackTrace();
           }
       }
   }
}

##线程API

/**
 * 获取线程相关信息的一组方法
 */
public class ThreadInfoDemo {
    public static void main(String[] args) {
        Thread main = Thread.currentThread();//获取主线程

        String name = main.getName();//获取线程的名字
        System.out.println("名字:"+name);

        long id = main.getId();//获取该线程的唯一标识
        System.out.println("id:"+id);

        int priority = main.getPriority();//获取该线程的优先级
        System.out.println("优先级:"+priority);

        boolean isAlive = main.isAlive();//该线程是否活着
        System.out.println("是否活着:"+isAlive);

        boolean isDaemon = main.isDaemon();//是否为守护线程
        System.out.println("是否为守护线程:"+isDaemon);

        boolean isInterrupted = main.isInterrupted();//是否被中断了
        System.out.println("是否被中断了:"+isInterrupted);
    }
}

##线程优先级
线程start后会纳入到线程调度器中统一管理，线程只能被动的被分配时间片并发运行,而无法主动索取时间片。线程调度器尽可能均匀的将时间片分配给每个线程。线程有10个优先级,使用整数1-10表示1为最小优先级，10为最高优先级，5为默认值调整线程的优先级可以最大程度的干涉获取时间片的几率.优先级越高的线程获取时间片的次数越多，反之则越少。

public class PriorityDemo {
    public static void main(String[] args) {
        Thread max = new Thread(){
            public void run(){
                for(int i=0;i<10000;i++){
                    System.out.println("max");
                }
            }
        };
        Thread min = new Thread(){
            public void run(){
                for(int i=0;i<10000;i++){
                    System.out.println("min");
                }
            }
        };
        Thread norm = new Thread(){
            public void run(){
                for(int i=0;i<10000;i++){
                    System.out.println("nor");
                }
            }
        };
        min.setPriority(Thread.MIN_PRIORITY);
        max.setPriority(Thread.MAX_PRIORITY);
        min.start();
        norm.start();
        max.start();
    }
}

##sleep阻塞
线程提供了一个静态方法:static void sleep(long ms)使运行该方法的线程进入阻塞状态指定的毫秒，超时后线程会自动回到RUNNABLE状态等待再次获取时间片并发运行。
public class SleepDemo {
    public static void main(String[] args) {
        System.out.println("程序开始了!");
        try {
            Thread.sleep(5000);//主线程阻塞5秒钟
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("程序结束了!");
    }
}
sleep方法处理异常:InterruptedException.

当一个线程调用sleep方法处于睡眠阻塞的过程中，该线程的interrupt()方法被调用时，sleep方法会抛出该异常从而打断睡眠阻塞。

##守护线程
守护线程也称为:后台线程
守护线程是通过普通线程调用setDaemon(boolean on)方法设置而来的，因此创建上与普通线程无异。守护线程的结束时机上有一点与普通线程不同,即:进程的结束。
进程结束:当一个进程中的所有普通线程都结束时，进程就会结束，此时会杀掉所有正在运行的守护线程。

/*
主要区别体现在当java进程中所有的普通线程都结束时进程会结束，
在结束前会杀死所有还在运行的守护线程。
*/
setDaemon(true);//设置守护线程必须在线程启动前进行

多线程并发安全问题：
当多个线程并发操作同一临界资源，由于线程切换的时机不确定，导致操作顺序出现
混乱，严重时可能导致系统瘫痪。
临界资源:同时只能被单一线程访问操作过程的资源。

### synchronized关键字

##synchronized关键字的使用

//语法
synchronized(同步监视器对象){
   需要多线程同步执行的代码片段
}

1.在方法上修饰，此时该方法变为一个同步方法

当一个方法使用synchronized修饰后,这个方法称为"同步方法",即:多个线程不能同时在方法内部执行。只能有先后顺序的一个一个进行。将并发操作同一临界资源的过程改为同步执行就可以有效的解决并发安全问题.

public synchronized int getBean(){
    if(beans==0){
        throw new RuntimeException("同步结束");
    }
    Thread.yield();//主动放弃本次时间片。
    return beans--;
}

2.同步块：可以更准确的锁定需要排队的代码片段

有效的缩小同步范围可以在保证并发安全的前提下尽可能的提高并发效率。同步块可以更准确的控制需要多个线程排队执行的代码片段。

synchronized(this){ //this指向使用的本类对象
    System.out.println("同步块执行");
    Thread.sleep(5000);
}

3. 在静态方法上，使用synchronized

class Boo{
    /**
     * synchronized在静态方法上使用是，指定的同步监视器对象为当前类的类对象。
     * 即:Class实例。
     * 在JVM中，每个被加载的类都有且只有一个Class的实例与之对应，后面讲反射
     * 知识点的时候会介绍类对象。
     */
    public synchronized static void dosome(){
        Thread t = Thread.currentThread();
        try {
            System.out.println(t.getName() + ":正在执行dosome方法...");
            Thread.sleep(5000);
            System.out.println(t.getName() + ":执行dosome方法完毕!");
        } catch (InterruptedException e) {
            e.printStackTrace();
            }
        }
    }
}

//静态方法中使用同步块时,指定的锁对象通常也是当前类的类对象
class Boo{
    public static void dosome(){
        /*
            静态方法中使用同步块时，指定同步监视器对象通常还是用当前类的类对象
            获取方式为:类名.class
         */
        synchronized (Boo.class) {
            Thread t = Thread.currentThread();
            try {
                System.out.println(t.getName() + ":正在执行dosome方法...");
                Thread.sleep(5000);
                System.out.println(t.getName() + ":执行dosome方法完毕!");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

##互斥锁

当多个线程执行不同的代码片段，但是这些代码片段之间不能同时运行时就要设置为互斥的。使用synchronized锁定多个代码片段，并且指定的同步监视器是同一个时，这些代码片段之间就是互斥的。