Java 并发编程学习笔记（1）--线程的基础

线程

   一个程序有多个任务，每个任务就是一个线程。在我看来，线程就是进程里的任务，负责处理一个程序里的组件。可能回重复一个方法。

线程的状态

  并不同于大多数文章中说的，其实线程有6中状态，既新创建（New），可运行（Rnnable），被阻塞（Blocked），等待（Waiting），计时等待（Time waiting），被终止（Terminated）。

其中各中状态，

当用new操作符创建一个线程后，当线程还没有运行时，既处于新创建状态。

当调用start方法后，线程就处于Runnable 状态，其实该状态就为就绪和运行状态，他不必始终保持运行。

一个线程被阻塞或等待的方式有3中，

1.为了防止线程间共用数据，当线程运行时被其他线程调用破坏数据，采用锁对象（synchronized、显示锁、条件等）防止代码块受并发访问干扰。当其他线程释放锁时，该线程获得该锁，接触被阻塞。

2.当该线程通知线程调度器自己进入等待状态。

3.这几个方法有超时参数。调用后进入计时等待。

被终止：run方法自己终止/一个异常终止。

线程的实现有两种方式，一是继承Thread类，二是实现Runnable接口，但不管怎样，当我们new了thread实例后，线程就进入了初始状态；

开启一个线程

继承Thread父类

public class myThread extends Thread {
    private  int i = 0;
    public void run() {
        while (true) {
            i++;
            System.out.println(i);
            if (i%10 == 0){
                try {
                    Thread.sleep(10000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

Thread thread = new myThread();
        thread.start();

实现Runnable方法

public class myThread implements Runnable  {
    private  int i = 0;
    public void run() {
        while (true) {
            i++;
            System.out.println(i);
            if (i%10 == 0){
                try {
                    Thread.sleep(10000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

Runnable thread = new myThread();
new Thread(thread).start();

用lambda实现r

 Runnable r = () ->{
        try
        {
            while(true)
            {
                int toAcccount = (int)(aim1.size()*Math.random());
                double amount = MAX_AMOUNT*Math.random();
                aim1.transfer(fromAccount,toAcccount,amount);
                Thread.sleep((int) (Dealay * Math.random()));

            }
        }catch (InterruptedException e)
        {

        }
    };
    Thread t = new Thread(r);
    t.start();
}

等方法来启动线程