美文网首页
互联网架构师笔记

互联网架构师笔记

作者: 韩志超 | 来源:发表于2020-01-21 15:15 被阅读0次

互联网架构师学习笔记整理-完善中

一、并发编程 + ActiveMQ + 实战案例

并发编程基础篇

第一天

1、课程大纲简要介绍

学习目的
面试
提高技术
发现类似并非/分布式/并行处理问题

2、线程基础概念、线程安全概念、多个线程多个锁概念
线程安全

概念：当多个线程访问某一个类（对象或方法）时，这个类始终都能表现出正确的行为，那么这个类（对象/方法）是线程安全的
synchronized: 可以在任意对象方法上加锁，而加锁的这段代码被称为“互斥区”或“临界区”
示例：MyThread: 当多个线程访问maThread的run方法时，以排队的方式进行处理（这里排队时按照CPU分配的先后顺序而定的），一个线程想要执行synchronized修饰的方法里的代码，首先尝试获得锁，如果拿到锁，执行更改代码体，拿不到锁，这个线程就会不断的尝试获得这把锁，知道拿到为止，而且是多线程去竞争这把锁（也就是会有锁竞争问题）。

public class MyThread extends Thread{
      
      private int count = 5;
        
      //synchronized加锁
      public synchronized void run(){
            count --;
            System.out.println(this.currentThread().getName() + " count = " + count);
      }
      public static void main(String[] args) {
            // TODO Auto-generated method stub
            MyThread myThread = new MyThread();
            Thread t1 = new Thread(myThread, "t1");
            Thread t2 = new Thread(myThread, "t2");
            Thread t3 = new Thread(myThread, "t3");
            Thread t4 = new Thread(myThread, "t4");
            Thread t5 = new Thread(myThread, "t5");
            t1.start();
            t2.start();
            t3.start();
            t4.start();
            t5.start(); 
      }
}
多个线程多个锁

synchronized只能对一个对象加锁，如果要对整个类加锁，需要将类声明为static对象，使所有实例都使用类对象
关键字synchronized取得的锁都是对象锁，而不是把一段代码（方法）当作锁，两个对象，线程获得的就是两个不同的锁，它们互不影响；
有一种情况则是相同的锁，即在静态方法上加synchronized关键字，表示锁定.class类，类一级别的锁（独占.class类）

package com.mymuti.sample02;
public class MutiThread {
      
      private static int num = 0;
      
      /** static **/
      public static synchronized void printNum(String tag){
            try {
                  if(tag.equals("a")){
                        num = 100;
                        System.out.println("tag a, set num over!");
                        Thread.sleep(1000);
                  }else {
                        num = 200;
                        System.out.println("tag b, set num over!");
                  }
                  System.out.println("tag " + tag + ", num = " + num);
            } catch (InterruptedException e){
                  e.printStackTrace();
            }
      }
      
      //注意观察run方法的输出
      public static void main(String[] args) {
            // TODO Auto-generated method stub
            
            //两个不同的对象
            final MutiThread m1 = new MutiThread();
            final MutiThread m2 = new MutiThread();
            
            Thread t1 = new Thread(new Runnable(){
                  @Override
                  public void run(){
                        m1.printNum("a");
                  }
            });
            
            Thread t2 = new Thread(new Runnable(){
                  @Override
                  public void run(){
                        m2.printNum("b");
                  }
            });
            
            t1.start();
            t2.start();
      }
}

同步和异步

synchronized

脏读

当读取线程较慢，写入线程教快时容易产生脏读---解决方法---读写同一个对象，用synchronized分别对读方法和写方法加锁。

synchronize其他概念

可以嵌套调用
支持继承
支持锁重入

package com.mymuti.lesson04_synchronized_02;
/**
 * synchronized的重入
 * @author Administrator
 *
 */
public class SyncDubbo1 {
      
      public synchronized void method1(){
            System.out.println("method1..");
            method2();
      }
      public synchronized void method2(){
            System.out.println("method2..");
            method3();
      }
      public synchronized void method3(){
            System.out.println("method3..");
      }
      public static void main(String[] args) {
            // TODO Auto-generated method stub
            final SyncDubbo1 sd = new SyncDubbo1();
            Thread t1 = new Thread(new Runnable(){
                  @Override
                  public void run(){
                        sd.method1();
                  }
            });
            t1.start();
      }
}

package com.mymuti.lesson04_synchronized_02;
/**
 * synchronized的重入
 * @author Administrator
 *
 */
public class SyncDubbo2 {
      static class Main{
            public int i = 10;
            public synchronized void operationSup(){
                  try {
                        i--;
                        System.out.println("Main print i = " + i);
                        Thread.sleep(100);
                  } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                  }
                  
            }
      }
      
      static class Sub extends Main {
            public synchronized void operationSub(){
                  try {
                        while(i > 0){
                              i--;
                              System.out.println("Sub print i = " + i);
                              Thread.sleep(100);
                              this.operationSup();
                        }
                  } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                  }
            }
      }
      public static void main(String[] args) {
            // TODO Auto-generated method stub
            Thread t1 = new Thread(new Runnable() {
                  @Override
                  public void run() {
                        Sub sub = new Sub();
                        sub.operationSub();
                  }
            });
            t1.start();
      }
}

package com.mymuti.lesson04_synchronized_02;
/**
 * synchronized异常
 * @author Administrator
 *
 */
public class SyncException {
      private int i = 0;
      public synchronized void operation(){
            while(true){
                  try {
                        i++;
                        Thread.sleep(200);
                        System.out.println(Thread.currentThread().getName() + " , i = " + i);
                        if(i==10){
                              Integer.parseInt("a");
                              //throw new RuntimeException();
                        }
                  } catch (Exception e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                        System.out.println(" log info i =" + i);
                        //throw new RuntimeException();
                        //continue;
                  }
            }
      }
      public static void main(String[] args) {
            // TODO Auto-generated method stub
            final SyncException se = new SyncException();
            Thread t1 = new Thread(new Runnable() {
                  @Override
                  public void run() {
                        se.operation();
                  }
            },"t1");
            t1.start();
      }
}
synchronize代码块
  1. Object lock--使用任意的Object进行枷锁，用法比较灵活
  2. String lock---不要使用String的常量加锁，会出现死循环问题
  3. 锁对象改变---对一个对象进行加锁的时候要注意对象本身是否发生改变，改变，那么持有的锁不同
  4. 死锁问题
package com.mymuti.lesson05_synchronized_03;
public class ObjectLock {
      public void method1(){
            synchronized (this){ //对象锁,this代表ObjectLock
                  try {
                        System.out.println("do method1..");
                        Thread.sleep(2000);
                  } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                  }
            }
      }
      public void method2(){
            synchronized (ObjectLock.class) {
                  try {
                        Thread.sleep(2000);
                        System.out.println("do method2..");
                  } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                  }
            }
      }
      
      public Object lock = new Object();
      public void method3(){ //任何对象锁
            synchronized (lock){
                  try {
                        System.out.println("do method3..");
                        Thread.sleep(2000);
                  } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                  }
            }
      }
      public static void main(String[] args) {
            // TODO Auto-generated method stub
            ObjectLock ol = new ObjectLock();
            Thread t1 = new Thread(new Runnable(){
                  @Override
                  public void run(){
                        ol.method3();
                        ol.method1();
                        ol.method2();
                        
                  }
            });
            t1.start();
      }
}

package com.mymuti.lesson05_synchronized_03;
public class StringLock {
      public void method(){
            //new String("字符串常量");
            //synchronized("字符串常量"){
            synchronized(new String("字符串常量")){
                  while(true){
                        try {
                              System.out.println("当前线程： " + Thread.currentThread().getName() + "开始");
                              Thread.sleep(1000);
                              System.out.println("当前线程： " + Thread.currentThread().getName() + "结束");
                        } catch (InterruptedException e) {
                              // TODO Auto-generated catch block
                              e.printStackTrace();
                        }
                        
                  }
            }
      }
      public static void main(String[] args) {
            // TODO Auto-generated method stub
            final StringLock stringLock = new StringLock();
            Thread t1 = new Thread(new Runnable() {
                  @Override
                  public void run() {
                        stringLock.method();
                  }
            },"t1");
            
            Thread t2 = new Thread(new Runnable() {
                  @Override
                  public void run() {
                        stringLock.method();
                  }
            },"t2");
            t1.start();
            t2.start();
            
      }
}
package com.mymuti.lesson05_synchronized_03;
public class ModifyLock {
      private String name;
      private int age;
      
      public String getName() {
            return name;
      }
      public void setName(String name){
            this.name = name;
      }
      public int getAge() {
            return age;
      }
      public void setAge (int age){
            this.age = age;
      }
      
      public synchronized void changeAttributte(String name, int age){
            try {
                  System.out.println("当前线程： " + Thread.currentThread().getName() + "开始");
                  this.setName(name);
                  this.setAge(age);
                  System.out.println("当前线程： " + Thread.currentThread().getName() + "修改对象内容为：" + this.getName() + "," + this.getAge());
                  Thread.sleep(2000);
                  System.out.println("当前线程： " + Thread.currentThread().getName() + "结束");
            } catch (InterruptedException e) {
                  // TODO Auto-generated catch block
                  e.printStackTrace();
            }
      }
      
      public static void main(String[] args) {
            // TODO Auto-generated method stub
            final ModifyLock modifyLock = new ModifyLock();
            Thread t1 = new Thread(new Runnable() {
                  @Override
                  public void run() {
                        modifyLock.changeAttributte("张三",20);
                  }
            },"t1");
            
            Thread t2 = new Thread(new Runnable() {
                  @Override
                  public void run() {
                        modifyLock.changeAttributte("李四",21);
                  }
            },"t2");
            t1.start();
            t2.start();
      }
}

package com.mymuti.lesson05_synchronized_03;
public class ChangeLock {
      private String lock = "lock";
      private void method(){
            synchronized (lock){
                  try {
                        System.out.println("当前线程： " + Thread.currentThread().getName() + "开始");
                        lock = "change lock";  //尽量不要修改lock的内容
                        Thread.sleep(6000);
                        System.out.println("当前线程： " + Thread.currentThread().getName() + "结束");
                  } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                  }
            }
      }
      public static void main(String[] args) {
            // TODO Auto-generated method stub
            final ChangeLock changeLock = new ChangeLock();
            Thread t1 = new Thread(new Runnable() {
                  @Override
                  public void run() {
                        changeLock.method();
                  }
            },"t1");
            
            Thread t2 = new Thread(new Runnable() {
                  @Override
                  public void run() {
                        changeLock.method();
                  }
            },"t2");
            t1.start();
            t2.start();
      }
}
3、对象锁的同步和异步
4、脏读概念、脏读业务场景
5、Synchronized概念、Synchronized代码块、Synchronized其他细节

第二天

1、Volatile关键字概念、线程优化执行流程、内部原理讲解
2、Volatile关键字的非原子性
3、并发编程下的多线程间通信概念wait、notify，线程经典面试题讲解
4、模拟底层阻塞队列（queue）实现讲解
5、单例和多线程如何结合使用

并发编程中级篇

第三天

1、同步类容器讲解
2、并发类容器讲解
3、Concurrent集合类讲解与底层原理实现
4、CopyOnWrite集合类讲解与底层原理实现
5、各类并发Queue详细讲解

第四天

1、多线程设计模式之Future模式讲解与模拟实现
2、多线程设计模式之Master-Worker模式讲解与模拟实现
3、多线程设计模式之生产消费者模型讲解与模拟实现

并发编程高级篇

第五天

1、JDK多任务执行框架底层讲解与内部实现
2、默认线程池说明、底层代码讲解
3、自定义线程池说明、底层代码讲解
4、线程池拒绝策略讲解
5、并发编程中的CountDownLatch与CyclicBarrier的使用

第六天

1、并发编程中Future和Callable使用
2、互联网进行限流策略的Semaphore信号量使用
3、并发编程中的重入锁使用
4、并发编程中的读写分离锁使用

并发编程框架篇

第七天

1、无锁并行计算框架初步学习入门
2、无锁并行计算框架HelloWorld示例讲解
3、无锁并行计算框架底层实现讲解与RingBuffer数据结构讲解
4、无锁并行计算框架EventProcessor和WorkPool的使用

第八天

1、无锁并行计算框架构建复杂消费模型讲解
2、无锁并行计算框架多生产者多消费者模型讲解
3、无锁并行计算框案例使用实现讲解

ActiveMQ

第九天

1、JMS规范简介
2、ActiveMQ入门示例
3、ActiveMQ安全机制
4、ActiveMQ持久化机制

第十天

1、ActiveMQ API讲解（一）
2、ActiveMQ API讲解（二）
3、ActiveMQ API讲解（三）

第十一天

1、点对点与发布订阅模式
2、取模实现负载均衡和多线程并发消费
3、与Spring整合异步发送邮件

第十二天

1、Zookeeper环境搭建
2、Activemq集群环境搭建

二、网络编程 + 实战案例 + JVM调优

网络编程基础篇

第一天

1、网络编程Socket知识点回顾
2、网络编程的伪异步IO模式讲解
3、网络编程的NIO模型概念和原理讲解
4、Buffer API讲解

第二天

1、网络编程的NIO编程模型讲解
2、网络编程的AIO编程模型讲解

网络编程中级篇

第三天

1、通信框架Netty之HelloWorld入门示例
2、通信框架Netty的多端口使用
3、通信框架Netty的长连接短连接使用
4、通信框架Netty的实战部署Netty服务讲解

第四天

1、通信框架Netty的TCP粘包拆包讲解
2、通信框架Netty的序列化框架讲解
3、通信框架Netty的自定义协议讲解

网络编程高级篇

第五天

1、通信框架Netty最佳实践一（实际项目中做数据通信）
2、通信框架Netty最佳实践二（集群中进行心跳检测服务）

第六天

1、通信框架Netty实现Http协议讲解
2、通信框架Netty文件下载讲解
3、通信框架Netty文件上传讲解

第七天

1、数据交换项目通信服务场景讲解

并发编程框架篇

第八天

1、jvm虚拟机组成部分讲解
2、jvm虚拟机参数使用讲解

第九天

1、jvm垃圾收集算法讲解
2、jvm新生代老年代参数配置
3、jvm垃圾收集器讲解

第十天

1、Jmeter讲解
2、jvm优化对Tomcat性能的影响测试
3、jconsole讲解

三、Redis + Lua + SSDB + Oracle

Redis + Lua + SSDB

第一天

1、NoSQL简介与Redis介绍
2、Redis环境安装

第二天

1、Redis数据类型String
2、Redis数据类型Hash
3、Redis数据类型List
4、Redis数据类型Set和ZSet

第三天

1、Redis高级命令
2、Redis安全性
3、Redis主从复制
4、Redis哨兵

第四天

1、Redis事务
2、Redis持久化机制
3、Redis发布与订阅模式
4、Redis的java api操作

第五天

1、Lua脚本简介
2、Lua安装与语法使用
3、Redis与Lua集成
4、Java API操作Redis调用Lua脚本

第六天

1、SSDB简介
2、SSDB使用
3、SSDB集群、主从、主主、多主
4、JAVA使用SSDB

第七天

1、Redis集群概念说明
2、Redis集群环境搭建与使用
3、Java操作Redis集群

第八天

1、Redis集群操作（一）
2、Redis集群操作（二）
3、Redis集群操作（三）

Oracle

第九天

1、Oracle基础回顾
2、Oracle高级使用
3、Oracle分析函数

第十天

1、Oracle之用户操作
2、Oracle之事务和锁
3、Oracle之索引和索引碎片问题解决

第十一天

1、Oracle之数据库设计概述
2、Oracle之物化视图

第十二天

1、Oracle之同义词，DBLINK，表空间
2、Oracle之垂直水平分库分表

第十三天

1、Oracle之表分区、分区索引

第十四天

1、使用Powerdesigner设计数据库表
2、Oracle之数据库设计实战案例分析（分析+设计+存储过程实现）

四、Zookeeper + RocketMQ + 实战案例

Zookeeper

第一天

1、Zookeeper简介
2、Zookeeper集群环境搭建
3、Zookeeper客户端使用
4、Zookeeper 配置文件讲解

第二天

1、Zookeeper 原生API讲解

第三天

1、Zookeeper Watcher核心机制讲解
2、Zookeeper 安全认证讲解
3、Zookeeper 实际应用讲解

第四天

1、ZKClientAPI讲解
2、ZKClientListener讲解
3、CuratorAPI讲解
4、CuratorCacheListener讲解
5、Curator分布式锁讲解
6、Curator分布式计数器讲解
7、Curator分布式Barrier讲解
8、Curator实现多个Watcher集群操作

RocketMQ

第五天

1、RocketMQ简介
2、RocketMQ环境搭建

第六天

1、RocketMQ HelloWorld示例
2、RocketMQ 重试策略讲解

第七天

1、RocketMQ 双主双从集群环境搭建
2、RocketMQ 架构讲解

第八天

1、RocketMQ顺序消费
2、RocketMQ事务消费

第九天

1、RocketMQ拉取机制
2、RocketMQ API使用简介
3、RocketMQ FilterServer使用

第十天

1、RocketMQ实战案例讲解

五、Jenkins+ Dubbo + Dubbox + 实战案例

Dubbo

第一天

1、Dubbo分布式服务治理简介
2、Dubbo入门示例讲解
3、Dubbo管控台部署使用

第二天

1、依赖检查讲解
2、集群容错配置讲解
3、负载均衡配置讲解
4、其他细节配置使用讲解

第三天

1、Dubbox入门讲解
2、Dubbox Rest讲解
3、Dubbox 容器讲解
4、Dubbox Kryo序列化框架

第四天

1、关于项目的搭建与在linux平台下部署dubbo服务

持续集成框架说明

第五天

1、持续集成环境搭建SVN+MAVEN+NEXUS搭建（一）
2、持续集成环境搭建SVN+MAVEN+NEXUS搭建（二）
3、持续集成环境搭建SVN+MAVEN+NEXUS搭建（三）

第六天

1、持续集成环境搭建JENKINS搭建与使用（一）
2、持续集成环境搭建JENKINS搭建与使用（二）
3、持续集成环境搭建JENKINS搭建与使用（三）

第七天

1、单点登录概述2、单点登录讲解
3、单点登录windows平台环境搭建

第八天

1、单点登录Linux部署与实现（一）
2、单点登录Linux部署与实现（二）

第九天

1、项目中实现单点登录环境跳转功能

六、Storm + Kafka + Solr + 实战案例

Storm

第一天

1、分布式流式计算简介
2、环境搭建
3、HelloWorld示例讲解
4、Spout、Bolt、Topology概念
5、集群环境提交Topology

第二天

1、Worker、Executor、Task配置详解
2、分组模式讲解

第三天

1、WorldCount例子
2、保证机制
3、Drpc讲解

第四天

1、KafKa安装与使用
2、KafKaSpout使用

第五天

1、结合Redis使用
2、Trident学习使用
3、Solr

Solr

第六天

1、环境搭建
2、HelloWorld示例讲解
3、IK中文分词器安装与使用

第七天

1、javabean与solr注解使用
2、API使用讲解
3、SSI框架整合Solr使用讲解
4、管理员命令使用讲解

第八天

1、DIH全量同步Mysql数据讲解
2、DIH增量同步Mysql数据讲解

第九天

1、Solr集群环境搭建与使用

七、Nginx + keepalived + Fastdfs +实战案例

Nginx

第一天

1、Nginx入门简介
2、Nginx环境搭建
3、Nginx虚拟主机配置
4、Nginx日志分析
5、Nginx Location url过滤

第二天

1、Nginx集群环境搭建
2、Nginx+Keepalived使用
3、FastDFS

FastDFS

第三天

1、FastDFS简介
2、FastDFS环境搭建与使用

第四天

1、FastDFS集群环境搭建+Nginx缓存、负载均衡等整合
2、FastDFS集群API操作

第五天

1、Web项目与fastdfs集群进行整合，实现文件的上传下载等功能
2、Web项目实现对fastdfs文件进行定时任务清理工作

视频可微信添加lockingfree获取~

相关文章

  • 互联网架构师笔记

    互联网架构师学习笔记整理-完善中 一、并发编程 + ActiveMQ + 实战案例 并发编程基础篇 第一天 1、课...

  • 终于来了！阿里技术官耗时半年纯手写1046页Java架构师笔记上

    阿里技术官耗时半年纯手写1046页Java架构师笔记上线！！ 这份Java架构师笔记内容由浅入深，循序渐进，通过5...

  • xdl10

    互联网架构师之路 什么是架构师？架构师具备哪些能力？ 架构师类似于建筑行业的总设计师，通常在一个软件项目中，架构师...

  • 全栈工程师 10 笔记

    通往互联网架构师之路、全栈工程师 首先我们看什么是架构师？架构师应该具备哪些能力？大家都知道很多公司都有架构师这个...

  • 《架构师训练营》之技术方案与手段

    极客时间《架构师训练营》第四章学习笔记 这一章的学习笔记很可能与课后作业高度重合了，所以我不再泛泛列举各种互联网应...

  • Java互联网高级架构师高级进阶实战

    下载地址：Java互联网高级架构师高级进阶实战

  • XDL_NO.10 通往互联网架构师之路---全栈工程师

    通往互联网架构师之路---全栈工程师 1、首先我们看什么是架构师？架构师应该具备哪些能力？大家都知道很多公司都有架...

  • 按职责角色如何划分架构师

    对于网站和软件企业而言，架构师是一个重要的角色。本文将介绍按照职责角色如何划分架构师。 产品架构师 负责具体互联网...

  • 架构师知识体系

    架构师定位： 在互联网上可以找到各种各样的架构师定义，就连各种权威组织对架构师的整体定义都是不一致的。所以，这里不...

  • 通往架构师之路

    分布式集群的架构的架构师，也有着较高的要求，而互联网上受人敬仰的架构师大多属于这类。你也可以认为这才是真正的架构师...

网友评论

      本文标题：互联网架构师笔记

      本文链接：https://www.haomeiwen.com/subject/jdprzctx.html

      延伸阅读

      深度阅读

      • 您也可以注册成为美文阅读网的作者，发表您的原创作品、分享您的心情！

      栏目导航

      热点阅读

      关于我们|服务条款|联系我们|互联网架构师笔记|投稿指南|网站地图|RSS订阅|排版工具|手机版

      提供经典美文摘抄,优美散文欣赏,现代诗歌精选,短篇小说,心情随笔,表白情书范文,故事会在线阅读欣赏

      Copyright © 2014-2023 Haomeiwen.com All Rights Reserved. 好美文阅读网 版权所有

      备案信息：桂公网安备 45052102000051号 · 桂ICP备13007215号-3

      本站所收录作品、热点评论等信息部分来源互联网，目的只是为了系统归纳学习和传递资讯

      所有作品版权归原创作者所有，与本站立场无关，如不慎侵犯了你的权益，请联系我们告知，我们将做删除处理！