Java进阶之线程

Java进阶之线程
Java进阶之线程

Java进阶之线程

线程的概念
- 可以同步一起执行
- 线程和进程
- 并行和并发
- 同步和异步
线程运行机制
- 就绪状态(新生)
- 执行状态(执行)
- 挂起状态
- 死亡状态(终止)
- 每次在执行java.exe时，都会有一个java虚拟机进程启动，执行程序带代码的任务是由线程来完成的,所以，每一个线程都一个独立的程序计数器和方法调用栈
- 每当用Java命令启动一个Java虚拟机进程时，Java虚拟机都会创建一个主线程，该线程也就是main，也就是诚如的入口
使用线程
```
public class ExtendsThread extends Thread{
    private String name;
    public ExtendsThread(String name){
        this.name = name;
    }
    public void run(){
        for(int i = 1;i<=100;i++){
            System.out.println(name+"跑了"+i+"米");
        }
    }

    public static void main(String[] args) {
        ExtendsThread extendsThread1 = new ExtendsThread("李麒麟");
        ExtendsThread extendsThread2 = new ExtendsThread("吉祥物");
        ExtendsThread extendsThread3 = new ExtendsThread("神兽");
        extendsThread1.start();
        extendsThread2.start();
        extendsThread3.start();
    }
}
```
```
public class ImplementsRunnable implements Runnable{
    private String name;
    public ImplementsRunnable(String name){
        this.name = name;
    }
    @Override
    public void run() {
        for(int i = 1;i<=100;i++){
            System.out.println(name+"跑了"+i+"米");
        }
    }

    public static void main(String[] args) {
        ImplementsRunnable implementsRunnable1 = new ImplementsRunnable("起名字真是太难了");
        ImplementsRunnable implementsRunnable2 = new ImplementsRunnable("起名字真是超级难");
        ImplementsRunnable implementsRunnable3 = new ImplementsRunnable("起名字真是难爆了");
        Thread thread1 = new Thread(implementsRunnable1);
        Thread thread2 = new Thread(implementsRunnable2);
        Thread thread3 = new Thread(implementsRunnable3);
        thread1.start();
        thread2.start();
        thread3.start();
    }
}
```
```
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
public class ImplementsCallable implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        int i = 0;
        for (i = 0;i<20;i++){
            if(i == 10){
                break;
            }
        }
        return i;
    }

    public static void main(String[] args) {
        ImplementsCallable implementsCallable = new ImplementsCallable();
        FutureTask<Integer> futureTask = new FutureTask<>(implementsCallable);
        Thread thread1 = new Thread(futureTask,"线程1");
        thread1.start();
        try {
            System.out.println(Thread.currentThread().getName()+" "+futureTask.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}
```
- 常用方法
线程锁
```
public synchronized void sy(){
    //将方法加锁
}
```
```
public class TestTrainTickets {
    static class TrainTickets implements Runnable{
        int trainTickents = 100;
        @Override
        public void run(){
            while (trainTickents>0){
                synchronized (this){
                    if(trainTickents<=0){
                        System.out.println(Thread.currentThread().getName()+"没票了,请关注下次列车");
                        break;
                    }else{
                        System.out.println(Thread.currentThread().getName()+"出售车票第"+(100-trainTickents+1)+"张");
                        trainTickents--;
                    }
                    try {
                        Thread.sleep(new Random().nextInt(500)+1);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }

    public static void main(String[] args) {
        TrainTickets trainTickets = new TrainTickets();
        Thread thread1 = new Thread(trainTickets,"一号窗口");
        Thread thread2 = new Thread(trainTickets,"二号窗口");
        Thread thread3 = new Thread(trainTickets,"三号窗口");
        Thread thread4 = new Thread(trainTickets,"四号窗口");
        thread1.start();
        thread2.start();
        thread3.start();
        thread4.start();
    }
}
```
```
<!-- 
 public ReentrantLock(){
     //非公平锁
    sync = new NonfairSync();
}
public ReentrantLock(boolean fair){
    //true为公平锁，false为非公平锁
    sync = fair ? new FairSync() : new NonfairSync();
}
```
```
Lock lock = new ReentrantLock(true);//创建锁为公平锁
public void lock(){
    //加锁
    lock.lock();
    //被锁的内容    
    /释放锁
    lock.unlock();
}
```
- synchronized和lock的区别
- ConncurrentHashMap
- CountDownLatch
- 锁的应用场景
- 悲观锁和乐观锁
- 活锁和死锁
- 自旋锁和阻塞锁
线程的通讯
- 等待：wait()
- 等待一定时间：wait(long)
- 唤醒：notify()
- 唤醒所有：notifyAll()
- wait方法和sleep方法的区别
线程池
- 线程池的实现原理
- 线程池的工作机制
- 线程池体系结构
- 常用线程池
- 线程池的应用
如有问题，请发送邮件至buxiaqingcheng@163.com或者buxiaqingcheng@dingtalk.com
相关阅读:
NX二次开发-UFUN UF_UI_add_to_class_sel将UDOTestClass类的显示名称加入到类选择对话框的类列表中
 NX二次开发-UFUN创建管道UF_MODL_create_tube
NX二次开发-UFUN获得工作视图的tag UF_VIEW_ask_work_view
SQLyog/Mysql怎么修改用户/root密码【转载】
MySQL返回来的值都是字符串类型，还原每个字段【转载】
NX二次开发-NX访问MySQL数据库(增删改查)
NX二次开发-ug表达式函数ug_find_file读取当前prt所在路径【转发】
QT界面开发-QProgressBar【转载】
QT界面开发-使用new QComboBox添加触发事件
 QT界面开发-窗口滚动条【转发】
原文地址：https://www.cnblogs.com/zhenzhunaichabujiatang/p/13514876.html

Java进阶之线程

Java进阶之线程

线程的概念

线程运行机制

使用线程

线程锁

线程的通讯

线程池