学到哪，总结到哪之Java基础部分与线程实例

最新推荐文章于 2024-09-01 15:30:33 发布

小黑黑T_T

最新推荐文章于 2024-09-01 15:30:33 发布

阅读量156

点赞数

分类专栏：总结文章标签： java 多态多线程

本文链接：https://blog.csdn.net/qq_44900075/article/details/105675683

版权

总结专栏收录该内容

4 篇文章 0 订阅

订阅专栏

接触新技术网上搬砖

Gbase8m

我敲网上找不见内容

索引

索引详细

final关键词

final关键词的理解
主要几点

final修饰的类，不可被继承，其中属性还是可以修改
final修饰的方法，不可被重写
final修饰的变量、常量，初始化时，必须给赋值，之后不可以再次赋值。

static关键词

Java中static可以修饰成员变量和方法，还有一种特殊的内部类可以修饰（普通类是不允许static修饰的）

static修饰的内部类可以直接使用外部类创建实例 eg：new StaticClass.innerClass();
static修饰的内部方法可以直接使用当前类名直接调用 eg：MainClass.ClassMethods() or new MainClass().ClassMethods();
statiic修饰的成员变量称为静态变量，且该变量属于类，不属于对象；不被修饰的成员变量称为实例变量。
类初始化的顺序：父类静态变量>父类静态代码块>子类静态变量>子类静态代码块>父类普通变量>父类普通代码块>父类构造函数>子类普通变量>子类普通代码块>子类构造函数

深入理解static
原谅我对java的堆区、栈区没理解，导致我总结不下去了。记录一下，下次再深入学习（今天是2020/05/06）。

Java项目

Java项目经验篇

abstract关键词

abstract可以对类和方法进行修饰，但是不能分别同时和static、final、private一起使用。
abstract修饰的类，其中可以包含abstract修饰方法，也可以包含普通方法，但是非abstract修饰的类中不可以有abstract修饰的方法。
abstract修饰的方法，在该类下的子类中必须实现，若子类中还是由abstract修饰，可以继续继承该abstract修饰的方法，也可以实现该方法。

private、public、protected、默认的区别理解

public： 即公有的即表明该数据成员、成员函数是对所有用户开放的，所有用户均可以直接调用。
private： 即私有的，即表明除了自己之外，任何人不可以直接使用。
protected： 即保护的即只对该类子类，父类以及同package下可以自由使用，无限制，但是对于外部class，不可以直接使用，这是protected类似private。
默认： 即不添加任何修饰仅限当前类以及同package下，子类不可以直接使用，外部类也不可以。

线程实例

多线程demo1

最基础的公有三个窗口出售共100张票，简单理一下思路，首先是要让同时进行的三条线程进行抢着100张票，其次需要多继承，所以选用实现Runable接口来进行创建线程，而且考虑避免重复出售同一张票，合理利用线程锁保证数据安全。
话不多说上代码 ↓

public class MainClass{
	private static final Logger LOG = LoggerFactory.getLogger(MainClass.class);
	public static void main(String[] arg){
		Ticket ticket = new Ticket ();
        Thread window1 = new Thread(ticket ,"窗口1");
        Thread window2 = new Thread(ticket ,"窗口2");
        Thread window3 = new Thread(ticket ,"窗口3");
        window1 .start();
        window2 .start();
        window3 .start();
   }
	public  class Ticket implement Runable {
		private Object o = new Object();
	    int count = 100;
	    @Override
	    public void run() {
	        while (true){
	            try {
	                Thread.sleep(1);
	            } catch (InterruptedException e) {
	                e.printStackTrace();
	            }
	            synchronized (o){
	                if(count < 1){
	                    break;
	                }
	                LOG.info(Thread.currentThread().getName()+"正在售卖第"+count--+"号票");
	            }
	        }
	    }
	}
}
/*结果
15:29:45.542 [窗口3] INFO com.lsx.example.mythread.way.ThreadWay2 - 窗口3正在售卖第100号票
15:29:45.549 [窗口2] INFO com.lsx.example.mythread.way.ThreadWay2 - 窗口2正在售卖第99号票
15:29:45.550 [窗口1] INFO com.lsx.example.mythread.way.ThreadWay2 - 窗口1正在售卖第98号票
15:29:45.551 [窗口3] INFO com.lsx.example.mythread.way.ThreadWay2 - 窗口3正在售卖第97号票
15:29:45.552 [窗口2] INFO com.lsx.example.mythread.way.ThreadWay2 - 窗口2正在售卖第96号票
15:29:45.552 [窗口1] INFO com.lsx.example.mythread.way.ThreadWay2 - 窗口1正在售卖第95号票
15:29:45.553 [窗口3] INFO com.lsx.example.mythread.way.ThreadWay2 - 窗口3正在售卖第94号票
15:29:45.554 [窗口2] INFO com.lsx.example.mythread.way.ThreadWay2 - 窗口2正在售卖第93号票
15:29:45.554 [窗口1] INFO com.lsx.example.mythread.way.ThreadWay2 - 窗口1正在售卖第92号票
15:29:45.555 [窗口3] INFO com.lsx.example.mythread.way.ThreadWay2 - 窗口3正在售卖第91号票
15:29:45.556 [窗口1] INFO com.lsx.example.mythread.way.ThreadWay2 - 窗口1正在售卖第90号票
...
15:29:45.617 [窗口3] INFO com.lsx.example.mythread.way.ThreadWay2 - 窗口3正在售卖第10号票
15:29:45.617 [窗口1] INFO com.lsx.example.mythread.way.ThreadWay2 - 窗口1正在售卖第9号票
15:29:45.617 [窗口2] INFO com.lsx.example.mythread.way.ThreadWay2 - 窗口2正在售卖第8号票
15:29:45.619 [窗口3] INFO com.lsx.example.mythread.way.ThreadWay2 - 窗口3正在售卖第7号票
15:29:45.619 [窗口2] INFO com.lsx.example.mythread.way.ThreadWay2 - 窗口2正在售卖第6号票
15:29:45.619 [窗口1] INFO com.lsx.example.mythread.way.ThreadWay2 - 窗口1正在售卖第5号票
15:29:45.621 [窗口3] INFO com.lsx.example.mythread.way.ThreadWay2 - 窗口3正在售卖第4号票
15:29:45.621 [窗口1] INFO com.lsx.example.mythread.way.ThreadWay2 - 窗口1正在售卖第3号票
15:29:45.621 [窗口2] INFO com.lsx.example.mythread.way.ThreadWay2 - 窗口2正在售卖第2号票
15:29:45.623 [窗口1] INFO com.lsx.example.mythread.way.ThreadWay2 - 窗口1正在售卖第1号票
*/

多线程demo2

现有personA,personB俩人，分别利用ATM机、柜台从同一账户中取钱，代码奉上 ↓

public class MainClass{
	private static final Logger LOG = LoggerFactory.getLogger(MainClass.class);
	public static void mian(String[] arg){
	//获取同一账户下的金额，所以传入同一对象
		Bank bank = new Bank();
	    Person personA = new MainClass.Person("ATM", bank, 200);
	    Person personB = new Person("Reduce", bank, 100);
	    personA.start();
	    personB.start();
	}
	static class Bank {
        static double money = 1000;
        public void Reduce(double money) {
            Bank.money -= money;
            LOG.info("您本次在柜台取钱{}元，卡中现存余额{}元！", money, Bank.money);
        }
        public void ATM(double money) {
            Bank.money -= money;
            LOG.info("您本次在ATM中取钱{}元，卡中现存余额{}元！", money, Bank.money);
        }
        //提供一个对外取款途径，防止直接调取方法同时取款时，并发余额显示错误
        public synchronized void UPMoney(double money, String mode) throws Exception {
            if (money > Bank.money) {
                throw new Exception("取款金额" + money + ",余额只剩" + Bank.money + "，取款失败");
            }
            if (Objects.equals(mode, "ATM")) {
                ATM(money);
            } else {
                Reduce(money);
            }
        }
    }
    static class Person extends Thread {
        String mode;
        Bank bank;
        double money;
        Person(String mode, Bank bank, double money) {
            this.mode = mode;
            this.bank = bank;
            this.money = money;
        }
        @Override
        public void run() {
            while (bank.money >= money) {
                try {
                    bank.UPMoney(money, mode);
                    sleep(100);
                } catch ( Exception e) {
                    e.printStackTrace();
                } catch ( InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
/*结果
15:50:31.726 [Thread-0] INFO com.lsx.example.mythread.main.ThreadMainWay - 您本次在ATM中取钱200.0元，卡中现存余额800.0元！
15:50:31.748 [Thread-1] INFO com.lsx.example.mythread.main.ThreadMainWay - 您本次在柜台取钱100.0元，卡中现存余额700.0元！
15:50:31.849 [Thread-0] INFO com.lsx.example.mythread.main.ThreadMainWay - 您本次在ATM中取钱200.0元，卡中现存余额500.0元！
15:50:31.849 [Thread-1] INFO com.lsx.example.mythread.main.ThreadMainWay - 您本次在柜台取钱100.0元，卡中现存余额400.0元！
15:50:31.949 [Thread-0] INFO com.lsx.example.mythread.main.ThreadMainWay - 您本次在ATM中取钱200.0元，卡中现存余额200.0元！
15:50:31.949 [Thread-1] INFO com.lsx.example.mythread.main.ThreadMainWay - 您本次在柜台取钱100.0元，卡中现存余额100.0元！
15:50:32.052 [Thread-1] INFO com.lsx.example.mythread.main.ThreadMainWay - 您本次在柜台取钱100.0元，卡中现存余额0.0元！
*/

多线程demo3

龟兔赛跑，乌龟每0.1秒跑2米，期间不休息，兔子每0.1秒跑5米，其中每20米休息1秒，总长2000米，要求在最后其中一种动物获胜，另一种动物要停止线程。
代码奉上 ↓

public class MainClass{
	private static final Logger LOG = LoggerFactory.getLogger(MainClass.class);
	public static void main(String[] arg){
		AnimalExtend Tortoise = new AnimalExtend(2, "乌龟");
        AnimalExtend Rabbit = new AnimalExtend(5, "兔子");
        ToStop TortoiseStop = new ToStop(Tortoise);
        Rabbit.calltoback = TortoiseStop;
        ToStop RabbitStop = new ToStop(Rabbit);
        Tortoise.calltoback = RabbitStop;

        Tortoise.start();
        Rabbit.start();
	}
	public abstract static class Animal extends Thread {
        public int length = 2000;
		//定义抽象方法
        public abstract void runing();
        @Override
        public void run() {
            super.run();
            while (length > 0) {
                runing();
            }
        }
		//声明回调接口
        public interface Calltoback {
            public void win();
        }
		//创建回调实例
        public Calltoback calltoback;
    }
    public static class AnimalExtend extends Animal {
		//动物继承类   dis  速度   name 名称
        private int dis;
        private String name;

        public AnimalExtend(int dis, String name) {
            this.dis = dis;
            this.name = name;
        }

        @Override
        public void runing() {
            length -= dis;
            LOG.info("{}跑了{}米，距离终点还剩{}米", name, dis, length);
            if (length <= 0) {
                length = 0;
                LOG.info("{}获得胜利！", name);
                if (calltoback != null) {
                    calltoback.win();
                }
            }
            try {
                if ("兔子".equals(name)) {
                    if ((2000 - length) % 20 == 0) {
                        sleep(1000);
                    } else {
                        sleep(100);
                    }
                }else{
                    sleep(100);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    public static class ToStop implements Animal.Calltoback{
    	//实现回调
        Animal an;

        public ToStop(Animal an) {
            this.an = an;
        }
		//停止线程
        @Override
        public void win() {
            an.stop();
        }
    }
}
/*结果
16:04:12.503 [Thread-0] INFO com.lsx.example.mythread.main.ThreadMainWay - 乌龟跑了2米，距离终点还剩1998米
16:04:12.503 [Thread-1] INFO com.lsx.example.mythread.main.ThreadMainWay - 兔子跑了5米，距离终点还剩1995米
16:04:12.616 [Thread-1] INFO com.lsx.example.mythread.main.ThreadMainWay - 兔子跑了5米，距离终点还剩1990米
16:04:12.616 [Thread-0] INFO com.lsx.example.mythread.main.ThreadMainWay - 乌龟跑了2米，距离终点还剩1996米
16:04:12.716 [Thread-1] INFO com.lsx.example.mythread.main.ThreadMainWay - 兔子跑了5米，距离终点还剩1985米
16:04:12.717 [Thread-0] INFO com.lsx.example.mythread.main.ThreadMainWay - 乌龟跑了2米，距离终点还剩1994米
16:04:12.817 [Thread-1] INFO com.lsx.example.mythread.main.ThreadMainWay - 兔子跑了5米，距离终点还剩1980米
16:04:12.817 [Thread-0] INFO com.lsx.example.mythread.main.ThreadMainWay - 乌龟跑了2米，距离终点还剩1992米
16:04:12.917 [Thread-0] INFO com.lsx.example.mythread.main.ThreadMainWay - 乌龟跑了2米，距离终点还剩1990米
16:04:13.019 [Thread-0] INFO com.lsx.example.mythread.main.ThreadMainWay - 乌龟跑了2米，距离终点还剩1988米
16:04:13.125 [Thread-0] INFO com.lsx.example.mythread.main.ThreadMainWay - 乌龟跑了2米，距离终点还剩1986米
16:04:13.230 [Thread-0] INFO com.lsx.example.mythread.main.ThreadMainWay - 乌龟跑了2米，距离终点还剩1984米
16:04:13.334 [Thread-0] INFO com.lsx.example.mythread.main.ThreadMainWay - 乌龟跑了2米，距离终点还剩1982米
16:04:13.437 [Thread-0] INFO com.lsx.example.mythread.main.ThreadMainWay - 乌龟跑了2米，距离终点还剩1980米
16:04:13.540 [Thread-0] INFO com.lsx.example.mythread.main.ThreadMainWay - 乌龟跑了2米，距离终点还剩1978米
16:04:13.643 [Thread-0] INFO com.lsx.example.mythread.main.ThreadMainWay - 乌龟跑了2米，距离终点还剩1976米
16:04:13.752 [Thread-0] INFO com.lsx.example.mythread.main.ThreadMainWay - 乌龟跑了2米，距离终点还剩1974米
16:04:13.817 [Thread-1] INFO com.lsx.example.mythread.main.ThreadMainWay - 兔子跑了5米，距离终点还剩1975米
16:04:13.853 [Thread-0] INFO com.lsx.example.mythread.main.ThreadMainWay - 乌龟跑了2米，距离终点还剩1972米
16:04:13.918 [Thread-1] INFO com.lsx.example.mythread.main.ThreadMainWay - 兔子跑了5米，距离终点还剩1970米
...
16:05:51.711 [Thread-1] INFO com.lsx.example.mythread.main.ThreadMainWay - 兔子跑了5米，距离终点还剩465米
16:05:51.774 [Thread-0] INFO com.lsx.example.mythread.main.ThreadMainWay - 乌龟跑了2米，距离终点还剩30米
16:05:51.812 [Thread-1] INFO com.lsx.example.mythread.main.ThreadMainWay - 兔子跑了5米，距离终点还剩460米
16:05:51.875 [Thread-0] INFO com.lsx.example.mythread.main.ThreadMainWay - 乌龟跑了2米，距离终点还剩28米
16:05:51.976 [Thread-0] INFO com.lsx.example.mythread.main.ThreadMainWay - 乌龟跑了2米，距离终点还剩26米
16:05:52.076 [Thread-0] INFO com.lsx.example.mythread.main.ThreadMainWay - 乌龟跑了2米，距离终点还剩24米
16:05:52.177 [Thread-0] INFO com.lsx.example.mythread.main.ThreadMainWay - 乌龟跑了2米，距离终点还剩22米
16:05:52.278 [Thread-0] INFO com.lsx.example.mythread.main.ThreadMainWay - 乌龟跑了2米，距离终点还剩20米
16:05:52.379 [Thread-0] INFO com.lsx.example.mythread.main.ThreadMainWay - 乌龟跑了2米，距离终点还剩18米
16:05:52.479 [Thread-0] INFO com.lsx.example.mythread.main.ThreadMainWay - 乌龟跑了2米，距离终点还剩16米
16:05:52.580 [Thread-0] INFO com.lsx.example.mythread.main.ThreadMainWay - 乌龟跑了2米，距离终点还剩14米
16:05:52.681 [Thread-0] INFO com.lsx.example.mythread.main.ThreadMainWay - 乌龟跑了2米，距离终点还剩12米
16:05:52.782 [Thread-0] INFO com.lsx.example.mythread.main.ThreadMainWay - 乌龟跑了2米，距离终点还剩10米
16:05:52.813 [Thread-1] INFO com.lsx.example.mythread.main.ThreadMainWay - 兔子跑了5米，距离终点还剩455米
16:05:52.882 [Thread-0] INFO com.lsx.example.mythread.main.ThreadMainWay - 乌龟跑了2米，距离终点还剩8米
16:05:52.913 [Thread-1] INFO com.lsx.example.mythread.main.ThreadMainWay - 兔子跑了5米，距离终点还剩450米
16:05:52.983 [Thread-0] INFO com.lsx.example.mythread.main.ThreadMainWay - 乌龟跑了2米，距离终点还剩6米
16:05:53.014 [Thread-1] INFO com.lsx.example.mythread.main.ThreadMainWay - 兔子跑了5米，距离终点还剩445米
16:05:53.084 [Thread-0] INFO com.lsx.example.mythread.main.ThreadMainWay - 乌龟跑了2米，距离终点还剩4米
16:05:53.115 [Thread-1] INFO com.lsx.example.mythread.main.ThreadMainWay - 兔子跑了5米，距离终点还剩440米
16:05:53.185 [Thread-0] INFO com.lsx.example.mythread.main.ThreadMainWay - 乌龟跑了2米，距离终点还剩2米
16:05:53.285 [Thread-0] INFO com.lsx.example.mythread.main.ThreadMainWay - 乌龟跑了2米，距离终点还剩0米
16:05:53.285 [Thread-0] INFO com.lsx.example.mythread.main.ThreadMainWay - 乌龟获得胜利！
*/

线程池demo

public class MainClass{
	private static final Logger LOG = LoggerFactory.getLogger(MainClass.class);
	public static void main(String[] arg){
		ExecutorService service = Executors.newFixedThreadPool(5);
        CountDownLatch latch = new CountDownLatch(5);
        long start = System.currentTimeMillis();

        Future f1 = service.submit(new Callable<Object>() {

            @Override
            public Object call() throws Exception {
                String InValue = "INNNNNNNNNN==>Value1";
                String OutValue = "OUTTTTTTTTT==>Value1";
                String s = ThreadMainWay.getAll(InValue, OutValue);
                latch.countDown();
                return s;
            }
        });
        
        Future f2 = service.submit(new Callable<Object>() {

            @Override
            public Object call() throws Exception {
                String InValue = "INNNNNNNNNN==>Value2";
                String OutValue = "OUTTTTTTTTT==>Value2";
                String s = ThreadMainWay.getAll(InValue, OutValue);
                latch.countDown();
                return s;
            }
        });
        Future f3 = service.submit(new Callable<Object>() {

            @Override
            public Object call() throws Exception {
                String InValue = "INNNNNNNNNN==>Value3";
                String OutValue = "OUTTTTTTTTT==>Value3";
                String s = ThreadMainWay.getAll(InValue, OutValue);
                latch.countDown();
                return s;
            }
        });
        Future f4 = service.submit(new Callable<Object>() {

            @Override
            public Object call() throws Exception {
                String InValue = "INNNNNNNNNN==>Value4";
                String OutValue = "OUTTTTTTTTT==>Value4";
                String s = ThreadMainWay.getAll(InValue, OutValue);
                latch.countDown();
                return s;
            }
        });
        Future f5 = service.submit(new Callable<Object>() {

            @Override
            public Object call() throws Exception {
                String InValue = "INNNNNNNNNN==>Value5";
                String OutValue = "OUTTTTTTTTT==>Value5";
                String s = ThreadMainWay.getAll(InValue, OutValue);
//                执行完latch减1
                latch.countDown();
                return s;
            }
        });
        try {

            latch.await();
            LOG.info("F1完成{}",f1.get());
            LOG.info("F2完成{}",f2.get());
            LOG.info("F3完成{}",f3.get());
            LOG.info("F4完成{}",f4.get());
            LOG.info("F5完成{}",f5.get());
        } catch (ExecutionException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        service.shutdown();
        long end = System.currentTimeMillis();
        LOG.info("完成所有任务，总计耗时：{}",(end-start));
	} 
	public static String getAll(String inValue, String outValue) {
        long time = 0l;
        try {
            long start = System.currentTimeMillis();
            Thread.sleep((long) (Math.random() * (10000 - 1000 + 1) + 1000));
            long end = System.currentTimeMillis();
            time = end - start;
            LOG.info("完成InValue：{}==》OutValue：{}，耗时：{}", inValue, outValue, time);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return "任务返回运行结果,当前任务时间【" + time + "毫秒】";

    }
} 
/*结果
16:12:43.623 [pool-1-thread-5] INFO com.lsx.example.mythread.main.ThreadMainWay - 完成InValue：INNNNNNNNNN==>Value5==》OutValue：OUTTTTTTTTT==>Value5，耗时：1919
16:12:47.440 [pool-1-thread-3] INFO com.lsx.example.mythread.main.ThreadMainWay - 完成InValue：INNNNNNNNNN==>Value3==》OutValue：OUTTTTTTTTT==>Value3，耗时：5742
16:12:48.780 [pool-1-thread-1] INFO com.lsx.example.mythread.main.ThreadMainWay - 完成InValue：INNNNNNNNNN==>Value1==》OutValue：OUTTTTTTTTT==>Value1，耗时：7082
16:12:49.744 [pool-1-thread-4] INFO com.lsx.example.mythread.main.ThreadMainWay - 完成InValue：INNNNNNNNNN==>Value4==》OutValue：OUTTTTTTTTT==>Value4，耗时：8046
16:12:49.782 [pool-1-thread-2] INFO com.lsx.example.mythread.main.ThreadMainWay - 完成InValue：INNNNNNNNNN==>Value2==》OutValue：OUTTTTTTTTT==>Value2，耗时：8084
16:12:49.782 [main] INFO com.lsx.example.mythread.main.ThreadMainWay - F1完成任务返回运行结果,当前任务时间【7082毫秒】
16:12:49.782 [main] INFO com.lsx.example.mythread.main.ThreadMainWay - F2完成任务返回运行结果,当前任务时间【8084毫秒】
16:12:49.782 [main] INFO com.lsx.example.mythread.main.ThreadMainWay - F3完成任务返回运行结果,当前任务时间【5742毫秒】
16:12:49.782 [main] INFO com.lsx.example.mythread.main.ThreadMainWay - F4完成任务返回运行结果,当前任务时间【8046毫秒】
16:12:49.782 [main] INFO com.lsx.example.mythread.main.ThreadMainWay - F5完成任务返回运行结果,当前任务时间【1919毫秒】
16:12:49.783 [main] INFO com.lsx.example.mythread.main.ThreadMainWay - 完成所有任务，总计耗时：8156
*/