##什么是线程？_IT分享知识网

大家好，欢迎来到IT知识分享网。 ##什么是线程？"

在我们开始今天的线程之前，我们先来几道干货，是什么呢？就是我们一般取公司面试可能会被问道的面试题：

　　1，描述java中多线程运行原理,

　　2，会用继承方式的会创建多线程,

　　3，会用实现接口的方式的会创建多线程

　　4，能够说出线程6个状态的名称,

　　5，能够解决线程安全问题（同步代码块锁）

一。多线程

1.1并发与并行：

　　并发：两个或者两个以上的事件，同一段时间内发生

　　并行：两个或者两个以上的事件，同一时刻发生

1.2进程与线程：

　　进程：一个内存中运行的应用程序

　　线程：进程中一个执行单元复制当前进程中程序的执行一个进程中至少有一个线程一个进程是可以有多个线程的这个程序可以称为多线程程序

线程调度： jvm采用是抢式调度没有分时调度

1.3主线程：

　　其实我们从刚接触Java的时候，就已经开始接触主线程了，对的，那就是我们的main方法

　　作为程序的入口，它也作为我们程序运行的主线程存在

1.4创建线程类　　Thread类　　

　　概述： java. lang .Thread类代表线程所有的线程对象都必须是Thread类或者它的子类　

如何使用的步骤：

　　1，集成Thread类　　并重写run方法

　　2，创建Thread子类的实例就是创建了线程对象

　　3，调用线程对象的方法start（）启动线程　

public class MyThread extends Thread{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}

1.5　　Thread类　　重点

　　getName();　　获取线程的名字

　　start();　　　　启动线程

　　run();　　　　重写run’方法

　　sleep();　　　　休眠

　　currenThread();　　返回对当前正在执行的线程对象的引用

public class Test {
    public static void main(String[] args) {
        MyThread mt = new MyThread();
        mt.start();
        new MyThread().start();
        new MyThread().start();
        System.out.println(Thread.currentThread().getName());
    }
}

1.6实现接口方式　　重难点

　　创建线程的另一种方法就是声明实现Runnable接口的类，该类然后实现run方法　　

　　在用接口的时候我们一般要去先实现这个接口

创建多种线程的步骤：

　　　　1，创建实现Runnable

　　　　2，重写run方法

　　　　3，创建Runnable接口类的对象

　　　　4，创建Thread类对象　　构造方法里面传递Runnable接口里面的实现对象

　　　　5，调用Thread类中的start方法　　开启新的线程　　执行run方法

那么在这里相信很多人都会这样的疑惑：我们为啥要用实现的方法区创建多线程呢？

1，一个类如果集成了Thread类，不能集成其他类

2，一个类实现了Runnable接口还可以区集成其他类

public class Demo01Runnable {
    public static void main(String[] args) {
       //3创建Runnnable接口实现类的对象
         RunnableImpl ruirui = new RunnableImpl();
//     4  创建Thread类对象   构造方法中传递Runnable接口中的实现类对象
        Thread t = new Thread(ruirui);
//      5 调用Thread类中start  方法  开启新的线程   执行run方法
        t.start();
        //主线程开启
        for(int i= 0;i<20;i++){
            System.out.println(Thread.currentThread().getName()+"--->"+i);
        }
    }
}

二。线程安全

当我们使用多个线程访问同一个资源，并且多个线程中对资源有写的操作就容易出现线程安全问题解决 java中提供同步来解决 synchronized

那么相对的会有三种解决方法：

　　1，同步代码块

　　2，同方法

　　3，Lock锁

就拿我们买票的现实生活案例来说，一个窗口买票属于单线程，那么多个窗口卖票是不是就是多线程呢？

先看下我们如何区实现：

首先我们会创建一个类：

public class RunnableImpl implements  Runnable{
    // 定义共享资源   线程不安全
    private int ticket = 100;
    // 线程任务  卖票
    @Override
    public void run() {
        while(true){
            if(ticket>0){
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //卖票操作
                System.out.println(Thread.currentThread().getName()+"正在卖第"+ticket+"张票");
                ticket--;
            }
        }

    }
}

　　然后创建线程：

public class Demo01PayTicket {
    public static void main(String[] args) {
        RunnableImpl r  = new RunnableImpl();
        // 创建3个线程
        Thread t = new Thread(r);
        Thread t1 = new Thread(r);
        Thread t2= new Thread(r);
        t.start();
        t1.start();
        t2.start();
    }
}

　　这里我们以三线程为例

可是卖票容易出现一个问题，可能这个窗口卖的票，其他窗口也买，那么出现这个问题我们怎么解决？

　　二。1同步代码块的方法

它的步骤分为三步：

　　1，建立锁对象任意对象

　　2，必须保证多个线程使用的是同一个锁对象

　　3，把{}只让一个线程进

public class RunnableImpl implements  Runnable{
    // 定义共享资源   线程不安全
    private int ticket = 100;
    //在成员位置创建一个锁对象
    Object obj = new Object();
    // 线程任务  卖票
    @Override
    public void run() {
        while(true){
            //建立锁对象
            synchronized (obj){
                if(ticket>0){
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    //卖票操作
                    System.out.println(Thread.currentThread().getName()+"正在卖第"+ticket+"张票");
                    ticket--;
                }
            }

        }

    }
}

二。2同方法：

它的步骤是：

　　1，创建一个方法　　修饰符添加synchronized

　　2，把访问了共享数据的代码放进方法中

　　3，调用同步方法

public class RunnableImpl implements  Runnable{
    // 定义共享资源   线程不安全
    private int ticket = 100;
    // 线程任务  卖票
    @Override
    public void run() {
        while(true){
            payTicket();
        }
    }
    public synchronized void payTicket(){

        if(ticket>0){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //卖票操作
            System.out.println(Thread.currentThread().getName()+"正在卖第"+ticket+"张票");
            ticket--;
        }
    }
}

二。3Lock锁

它的步骤是：

1，在成员位置创建Lock接口的实现类 ReentrantLock

2，在可能会出现代码的问题前面调用lock方法

3，在可能会出现代码的问题后面，调用unlock方法释放锁对象

public class RunnableImpl implements  Runnable{
    // 定义共享资源   线程不安全
    private int ticket = 100;
    // 线程任务  卖票
//    1   在成员的位置  创建Lock接口的实现类 ReentrantLock
    Lock l = new ReentrantLock();

    @Override
    public void run() {
        while(true){
            // 2  在可能会出现代码的问题前面  调用lock 方法
            l.lock();
            if(ticket>0){
                try {
                    Thread.sleep(100);
                    //卖票操作
                    System.out.println(Thread.currentThread().getName()+"正在卖第"+ticket+"张票");
                    ticket--;
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    //3   在可能会出现代码的问题后面  调用unlock()   释放锁对象
                    l.unlock();
                }

            }
        }

    }
}

三。线程状态

概述：当线程被创建后，不是–启动就进入执行状态

　　1，New线程刚被创建但是未被启动

　　2，Runnable可运行JVM里的状态

　　3，Blocked阻塞

　　4，waiting无线等待一个线程在等待另外一个线程唤醒

　　5，TimeWaiting计时等待

　　6，Teminated被终止因为run（）正常退出而死亡

免责声明：本站所有文章内容,图片，视频等均是来源于用户投稿和互联网及文摘转载整编而成，不代表本站观点，不承担相关法律责任。其著作权各归其原作者或其出版社所有。如发现本站有涉嫌抄袭侵权/违法违规的内容,侵犯到您的权益，请在线联系站长,一经查实,本站将立刻删除。本文来自网络,若有侵权，请联系删除，如若转载，请注明出处：https://yundeesoft.com/34222.html

##什么是线程？

相关推荐

发表回复