线程创建的方式 有两种

第一种是继承Thread类 重写run方法 (个人偏向这一种实际中这种用的较多)

例如

  1. public class MyThead extends Thread {
  2.  
  3. int j=20;
  4. public void run(){
  5. for (int i = 0; i < 20; i++) {
  6. try {
  7. Thread.sleep(1000);
  8. } catch (InterruptedException e) {
  9. // TODO Auto-generated catch block
  10. e.printStackTrace();
  11. }
  12. System.out.println(this.getName()+",i="+j--);
  13. }
  14. }
  15. }

 这种自己测试时也很多人写

  1. new Thread(new Runnable() {
    @Override
    public void run() {
  2.  
  3. }
    }).start(); 这样不好控制线程但是平时写一下也没关系
  4.  
  5. 第二种第二种是实现Runnable接口
  1. public class Thread3 implements Runnable{
  2. @Override
  3. public void run() {
  4.  
  5. for (int i = 0; i < 20; i++) {
  6. try {
  7. Thread.sleep(1000);
  8. } catch (InterruptedException e) {
  9. // TODO Auto-generated catch block
  10. e.printStackTrace();
  11. }
  12. System.out.println("接口Runnable"+",i="+i--);
  13. }
  14.  
  15. }
  16.  
  17. }

  主线程调用方式

  1. public static void main(String[] args) throws InterruptedException {
  2.  
  3. MyThead myThead= new MyThead();
  4. MyThread1 myThead1= new MyThread1();
  5. Thread3 thread3=new Thread3();
  6. //thread3.run();//这样不是开线程运行
  7. Thread t = new Thread(thread3);
  8. t.start();
  9. myThead.start();
  10. myThead1.start();
  11.  
  12. }

  个人还是倾向继承Thead 赶脚方便

-------------------------------------------------------------------------------------------------------------------

线程实现后最多的也就是用到线程同步了(synchronized 关键字 其他锁以后说)

来自

  1. https://www.cnblogs.com/blueSkyline/p/8598099.html
    自己大一学的时候感觉懵逼的不行 ...三年后清晰不少
  1. public class SynMethod {
  2. private static final Object staticLockObj = new Object();
  3. /**
  4. * 对象锁,代码级别,同一对象争用该锁,this为SynMethod实例,synchronized的锁绑定在this对象上
  5. */
  6. public void method1() {
  7. synchronized (this) {
  8. for (int i = 0; i < 100; i++) {
  9.  
  10. System.out.println(Thread.currentThread().getName() + " synchronized loop " + i);
  11. }
  12. }
  13. }
  14.  
  15. /**
  16. * 对象锁,方法级别,同一对象争用该锁,普通(非静态)方法,synchronized的锁绑定在调用该方法的对象上,与上一个写法含义一致()
  17. */
  18. public synchronized void method2() {
  19. for (int i = 0; i < 500; i++) {
  20. System.out.println(Thread.currentThread().getName() + " synchronized loop " + i);
  21. }
  22. }
  23.  
  24. /**
  25. * 对象锁,代码级别,同一类争用该锁,绑定在staticLockObj上,不同SynMethod实例,拥有同一个staticLockObj对象
  26. */
  27. public void method3() {
  28. synchronized (staticLockObj) {
  29. for (int i = 0; i < 50; i++) {
  30. System.out.println(Thread.currentThread().getName() + " synchronized loop " + i);
  31. }
  32. }
  33. }
  34.  
  35. /**
  36. * 类锁,代码级别,同一类争用该锁
  37. */
  38. public void method4() {
  39. synchronized (SynMethod.class) {
  40. for (int i = 0; i < 50; i++) {
  41. System.out.println(Thread.currentThread().getName() + " synchronized loop " + i);
  42. }
  43. }
  44. }
  45.  
  46. /**
  47. * 类锁,方法级别,同一类争用该锁,synchronized的锁绑定在SynMethod.class上
  48. */
  49. public static synchronized void staticMethod() {
  50. for (int i = 0; i < 5; i++) {
  51. System.out.println(Thread.currentThread().getName() + " synchronized loop " + i);
  52. }
  53. }
  54. }

  解释的比较清楚 自己试一试才是关键 ........

为什么能加上去锁呢?对象头部都有一些标志位...详情百度

------------------------------------------------------------------------------------------

大一的时候看过一个多线程简单的例子 火车站卖票的例子 一个线程相当于一个窗口 开多个窗口同时买票 且不重复

但是看完之后有点懵逼 模棱两可也就过去了 现在明白不少 主要是上面的synchronized关键字 当然也可以用其他锁实现 先贴一下自己的例子

  1. public class Station extends Thread {
  2. public Station(String name) {
  3. super(name);// 给线程名字赋值
  4. }
  5. static int tick=50;
  6.  
  7. @Override
  8. public void run() {
  9. while (tick>0)
  10. {
  11. synchronized (Station.class) //同步这里不能写this 可以是类 this 只会在本对象生效 new 一个新的没办法共同使用
  12. {
  13. if (tick>0)
  14. {
  15. System.out.println(getName()+"卖了第"+tick+"张票");
  16. tick--;
  17. }else
  18. {
  19. System.out.println("票已经卖完");
  20. }
  21.  
  22. }
  23.  
  24. try {
  25. sleep(100);//这里让线程不得到CUP 一下否则可能一个线程把事情干完了 达不到模拟效果
  26. } catch (InterruptedException e) {
  27. e.printStackTrace();
  28. }
  29. }
  30. }
  31. }

  synchronized (Station.class) 可以使用注意不要用this 那样窗口买票可能会重复的...也可以 在station 类里面new 一个没用的object对象 用哪个对象当钥匙(因为你new 再多的对象还是用那一个object 看看synchronized 的前面的例子运行一下就明白很多) 这两种解决都可以

也可以station 类继承Runnable 接口 实现run方法 加锁的时候直接this  主方法new 一个对象  开启两个线程 也不会出问题

买票main函数

  1. Station station1=new Station("窗口1");
  2. Station station2=new Station("窗口2");
  3. Station station3=new Station("窗口3");
  4. station1.start();
  5. station2.start();
  6. station3.start();

第二种写法 道理一样的 加锁那里写 this

  1. public class Station1 implements Runnable{
  2. static int tick=1000;
  3. @Override
  4. public void run() {
  5.  
  6. while (tick>0)
  7. {
  8.  
  9. synchronized (this)
  10. {
  11. System.out.println(Thread.currentThread().getName()+"卖出了第"+tick+"张飘");
  12. tick--;
  13. try {
  14. Thread.sleep(1);
  15. } catch (InterruptedException e) {
  16. e.printStackTrace();
  17. }
  18. }
  19.  
  20. }
  21.  
  22. System.out.println("票已经卖完");
  23.  
  24. }
  25. }

  main

  1. Station1 station11=new Station1();
  2. Thread t1=new Thread(station11,"第一个");
  3. Thread t2=new Thread(station11,"第二个");
  4. t1.start();
  5. t2.start();

java多线程知识回顾(笔记)的更多相关文章

  1. Java多线程技术学习笔记(二)

    目录: 线程间的通信示例 等待唤醒机制 等待唤醒机制的优化 线程间通信经典问题:多生产者多消费者问题 多生产多消费问题的解决 JDK1.5之后的新加锁方式 多生产多消费问题的新解决办法 sleep和w ...

  2. Java基础知识回顾之七 ----- 总结篇

    前言 在之前Java基础知识回顾中,我们回顾了基础数据类型.修饰符和String.三大特性.集合.多线程和IO.本篇文章则对之前学过的知识进行总结.除了简单的复习之外,还会增加一些相应的理解. 基础数 ...

  3. java基础知识回顾之---java String final类普通方法

    辞职了,最近一段时间在找工作,把在大二的时候学习java基础知识回顾下,拿出来跟大家分享,如果有问题,欢迎大家的指正. /*     * 按照面向对象的思想对字符串进行功能分类.     *      ...

  4. JAVA多线程知识总结(二)

    本文是承接上一篇文章:JAVA多线程知识总结(一) 四.Java多线程的阻塞状态与线程控制  上文已经提到线程阻塞的集中具体类型.下面主要看引起JAVA线程阻塞的方法 1,join()-----让一个 ...

  5. java基础知识回顾之java Thread类学习(八)--java多线程通信等待唤醒机制经典应用(生产者消费者)

     *java多线程--等待唤醒机制:经典的体现"生产者和消费者模型 *对于此模型,应该明确以下几点: *1.生产者仅仅在仓库未满的时候生产,仓库满了则停止生产. *2.消费者仅仅在有产品的时 ...

  6. Java基础知识回顾(一):字符串小结

    Java的基础知识回顾之字符串 一.引言 很多人喜欢在前面加入赘述,事实上去技术网站找相关的内容的一般都应当已经对相应知识有一定了解,因此我不再过多赘述字符串到底是什么东西,在官网中已经写得很明确了, ...

  7. Java多线程编程(学习笔记)

    一.说明 周末抽空重新学习了下多线程,为了方便以后查阅,写下学习笔记. 有效利用多线程的关键是理解程序是并发执行而不是串行执行的.例如:程序中有两个子系统需要并发执行,这时候需要利用多线程编程. 通过 ...

  8. Java多线程学习开发笔记

    线程有有序性和可见性 多个线程之间是不能直接传递数据交互的,它们之间的交互只能通过共享变量来实现. 在多个线程之间共享类的一个对象,这个对象是被创建在主内存(堆内存)中,每个线程都有自己的工作内存(线 ...

  9. JAVA 多线程知识总结(一)

    一,线程的生命周期以及五种基本状态 关于JAVA线程的生命周期,首先看一下下面这张图 上图中基本上囊括了Java中多线程各重要知识点.掌握了上图中的各知识点,Java中的多线程也就基本上掌握了. Ja ...

随机推荐

  1. Jquery 事件 文本框常用

    1.只许输入类型 //只能输入整数和小数 function txtKeyUpDecimal(txtName) { getID(txtName).keyup(function(){ //keyup事件处 ...

  2. for in 与for 与hasOwnProperty

    在遍历一个对象的时候我们会使用到for in属性. 现有对象和数组如下: var filght = { number: 1, status: 'watit', arrival: [1,2,3], ad ...

  3. layer 当前页获取iframe页的DOM元素

    layer.layui  开启iframe 之后,获取iframe 内容做自定义处理. parent.layer.open({ type: , title: '任務執行狀況.', shadeClose ...

  4. Java中短路

    当使用逻辑运算符时,我们会遇到一种“短路”的现象.即一旦能够准确无误的确定整个表达式的值,就不再计算表达式余下的部分了.因此整个表达式靠后的部分有可能不被运算 /**短路 * @param args ...

  5. 执行脚本,且以脚本名保存log

    !/bin/bash path="/sys/devices/platform/soc/fd880000.i2c-pld/i2c-0/i2c-4/i2c-15/15-0060" f_ ...

  6. Apache Shiro安全(权限框架)学习笔记一

    1. 授权需要继承 AuthorizingRealm 类, 并实现其 doGetAuthorizationInfo 方法 2. AuthorizingRealm 类继承自 Authenticating ...

  7. mapreduce程序执行过程

    1.客户端程序,设置作业相关的配置和计算输入分片信息,向RM获取一个JOBID,提交作业信息(分片)到以作业ID为目录下,通知APP——MASTER 2.APP——MASTER,读取指定目录下的作业信 ...

  8. SwiftStack 因战略转变而裁员

    导读 销售团队在前段圣诞节来临前面临裁减的糟糕处境.企业云存储公司SwiftStack进行了裁员,人数不详,公司规模因此缩小. IT外媒The Register获悉,这家公司裁掉了大概一半的人员,但总 ...

  9. MessageBox函数

    <Windows程序设计>(第五版)(美Charles Petzold著) https://docs.microsoft.com/zh-cn/windows/desktop/apiinde ...

  10. iOS 批量上传图片的 3 种方法

    AFNetworking 在去年年底升级到了 3.0.这个版本更新想必有很多好处,然而让我吃惊的是,它并没有 batch request 接口.之前的 1.x 版本.2.x 版本都实现了这个很常见的需 ...