JAVA 学习十八： 线程的四种状态

1.包

/*
Package:
1.对类文件进行分类管理
2.给类提供多层命名空间
3.写在程序文件的第一行
4.类名的全称是 包名.类名
5.包也是一种封装形式

         public     protected     default    privata
同一类中  ok          ok            ok          ok

同一包中  ok          ok            ok

子类中    ok          ok

不同包中  ok


bao。类

import packa.Demo //导入包中的类
inport packa.* //导入包中的所有的类


导包的原则：用哪个导哪个

set 。。。 、haha.jar  将文件导成jar包


*/

2. 线程的第二种开启方法

/*
线程的四种状态：

创建、(start())运行、（run()方法结束/stop()）消亡、冻结（不再运行但还存在 sleep（time）方法/wait（） nitify（）唤醒）

cpu执行资格： 可以被cpu执行，但要排队

cpu执行权： 正在被cpu处理

冻结： 释放执行权的同时释放执行资格
*/

/*

创建线程的第二种方式：
接口实现线程：Runnable接口

1.定义类实现Runnable接口
2.覆盖接口方法中的run方法，将线程任务代码封装到run方法中。
3.通过Thread类创建线程对象，并将Runable接口的子类对象作为Thread 类的构造函数的参数进行传递。
4.通过线程对象的start方法开启线程


Runnable d = new Demo();
Runnable d1 = new Demo();
Thread t1 = new Thread(d);
Thread t1 = new Thread(d1);
t1.start();
t2.start();


继承Thread 与 实现Runnable 接口的区别：
1.实现Runable的好处
    1.将线程的任务从线程的子类分离出来，进行了单独的封装。按照面向对象的思想将任务封装成对象
    2.避免了java单继承的局限性

    所以创建线程的第二种方式较为常用



*/


class Demo implements Runnable
{
    public void run()
    {
        show();
    }

    public void show()
    {
        for (int i =0;i <=10 ;i++ )
        {
            System.out.println(Thread.currentThread().getName()+ x)
        }
    }
}


class ThreaDemo
{
    public static void main(String[] args)
    {
        Runnable d = new Demo();
        Thread t1 = new Thread(d);
        t1.start();
    }
}

3.同步

/*
需求：两个储户，每个储户都到银行存钱，每次存一百，共存三次
描述：




同步：
同步的前提：
    必须有多个线程并使用同一个锁

同步的好处： 解决了线程的安全问题

同步的弊端： 像对降低了效率，因为同步外的线程都会判断同步锁。
*/

class Ban
{
    private int sum;
    private Object obj = new Object(); 
    //public void add(int num)
    public synchronized void add(int sum)
    {
        synchronized(obj)//同步锁
        {sum = sum + num;
        System.out.println(sum);
    }
    }
}

class Cus implements Runnable

{
    private Ban b = new Ban();
    public void run()
    {

        for (int i =0;i<3;i++ )
        {
            b.add(100);
        }
    }
}

class Demo

{
    public static void main(String[] args)
    {
        Cus c = new Cus();
        Thread t1 = new Thread(c);
        Thread t2 = new Thread(c);
        t1.start();
        t2.start();
    }
}

4.应用

/*
需求：两个储户，每个储户都到银行存钱，每次存一百，共存三次
描述：




同步：
同步的前提：
    必须有多个线程并使用同一个锁

同步的好处： 解决了线程的安全问题

同步的弊端： 像对降低了效率，因为同步外的线程都会判断同步锁。
*/

class Ban
{
    private int sum;
    private Object obj = new Object(); 
    public void add(int num)
    {
        synchronized(obj)
        {sum = sum + num;
        System.out.println(sum);
    }
    }
}

class Cus implements Runnable

{
    private Ban b = new Ban();
    public void run()
    {

        for (int i =0;i<3;i++ )
        {
            b.add(100);
        }
    }
}

class Demo

{
    public static void main(String[] args)
    {
        Cus c = new Cus();
        Thread t1 = new Thread(c);
        Thread t2 = new Thread(c);
        t1.start();
        t2.start();
    }
}