小编pan*_*ajt的帖子

class ApplicationContext{
    private final NetworkObject networkObject = new networkObject();

    public ApplicationContext(){
      networkObject.setHost("host");
      networkObject.setParams("param");
    }

    public searchObjects(ObjectType objType){
        networkObject.doSearch(buildQuery(objType));
    }
}

class NetworkObject{
    private final SearchObject searchObject = new SearchObject();

    public doSearch(SearchQuery searchQuery){
        searchObject.search(searchQuery); //threadsafe, takes 15(s) to return
    }
}

考虑运行Web应用程序的Web服务器,该Web应用程序仅创建一个ApplicationContext实例(单例)并使用相同的applicationInstance来调用searchObjects,例如

 ApplicationContext appInstance = 
                  ApplicationContextFactory.Instance(); //singleton

每个对网页的新请求都说"search.jsp"会拨打电话

 appInstance.searchObjects(objectType);

我正在向'search.jsp'页面发出1000个请求.所有线程都使用相同的ApplicationContext实例,而searchObject.search()方法需要15秒才能返回.我的问题是当一个人已经在执行searchObject.search()函数或所有线程同时执行searchObject.search()时,所有其他线程是否等待轮到他们执行(15秒),为什么？

我希望我的问题非常明确？

更新: 感谢大家澄清我的疑问.这是我的第二个问题,当我这样做时应该观察到性能的差异:

public synchronized doSearch(SearchQuery searchQuery){
    searchObject.search(searchQuery); //threadsafe, takes 15(s) to return
}

要么

public doSearch(SearchQuery searchQuery){
    searchObject.search(searchQuery); //threadsafe, takes 15(s) to return
}

我相信使用没有synchronized关键字的'doSearch'功能应该可以提供更多性能.但是,当我今天测试它时,结果却出现了另一种情况.当我使用synchronized关键字时,性能相似或有时更好.

谁能解释这种行为.我应该如何调试这种情况.

问候,

佩里

任何人都可以解释为什么在重载运算符时需要返回引用,例如

friend std::ostream& operator<< (std::ostream& out, const std::string& str)

enum SQLErrorCode{
      OK = 0,
      PARTIAL_OK = 1,
      SOMEWHAT_OK = 2,
      NOT_OK = 3,
};

代码1:

int error = getErrorCode();
if((error == SQLErrorCode.PARTIAL_OK) ||
  (error == SQLErrorCode.SOMEWHAT_OK) ||
  (error == SQLErrorCode.NOT_OK) ||
  (error < 0))
   callFunction1();
else
    callFunction2();

代码2:

switch(error){
       case SQLErrorCode.PARTIAL_OK: 
                                    callFunction1();
                                    break;
        case SQLErrorCode.SOMEWHAT_OK:
                                    callFunction1();
                                    break;
        case SQLErrorCode.NOT_OK: 
                                    callFunction1();
                                    break;
        default:
                                    callFunction2();
                                    break;
}

我应该选择哪种方法.就性能而言,应该没有太大差异.如何在switch case中处理错误<0条件.

编辑:乔尔的解决方案:

switch(error) {
     case SQLErrorCode.PARTIAL_OK: 
     case SQLErrorCode.SOMEWHAT_OK:
     case SQLErrorCode.NOT_OK: 
         callFunction1();
         break;
     case SQLErrorCode.OK:
         callFunction2();
         break;
     default:     // error < 0 is handled …

有两种方法可以记录任何密码 - 我没有看到任何一个密码有任何问题.

1. Not log any password, just log the user.
2. Log '******' against the password. logger.info("User=" + user + "logged with Password=******");

我们对这些情况有什么最佳做法吗？

Q1.编写不消耗CPU但仍能获得出色性能的代码的最佳实践是什么？这个问题非常通用.我在这里寻求的是列出用于不同环境的不同实践？除了进程监视器/任务管理器之外的调试技巧

编辑:我不是在谈论IO绑定进程.我说的是CPU绑定过程.但是,在这里我不希望我的进程继续占用CPU.如果我有一台4核机器,并且如果我在一个过程中运行四个简单的循环,则CPU消耗量最多可达到400%,直到应用程序/进程运行.

我在这里寻求一些关于这个话题的经验,每个人都会遇到一些时间或其他.例如,一旦应用程序在Windows上占用CPU,我就会调试它,因为它不断循环搜索不存在的文件.

如何以两种不同的CPU绑定应用程序顺利运行(给出良好响应)的方式编写程序？

更新: 建议:

1. 写好干净的代码,然后配置您的应用程序,然后进行优化.(感谢提示)

2. 重写/重新设计/重构代码比分析和修复代码更容易.

3. 使用分析器调试您的应用程序

4. 对于长时间等待的线程,请勿使用自旋锁

5. 算法选择

这些建议对初学者理解概念有很大帮助.

我有一个大对象说MyApplicationContext,它保存有关MyApplication的信息,如名称,路径,loginInformation,描述,详细信息等.

// MyApplicationCtx

class MyApplicationCtx{
       // ....
    private:
        std::string name;
        std::string path;
        std::string desciption;
        struct loginInformation loginInfo;
        int appVersion;
        std::string appPresident;
        //others
}

这是我的方法cloneApplication(),它实际上设置了一个新的应用程序.有两种方法可以实现,如代码1和代码2所示.我应该选择哪一种？为什么？

//代码1

public void cloneApplication(MyApplicationCtx appObj){
    setAppName(appObj);
    setAppPath(appObj);
    setAppAddress(&appObj); // Note this address is passed
    setAppDescription(appObj);
    setAppLoginInformation(appObj);
    setAppVersion(appObj);
    setAppPresident(appObj);
}

public void setAppLoginInformation(MyApplicationCtx appObj){
    this->loginInfo = appObj.loginInfo; //assume it is correct
}

public void setAppAddress(MyApplicationCtx *appObj){
    this->address = appObj->address;
}

 .... // same way other setAppXXX(appObj) methods are called.

Q1.每次传递大对象appObj都会对性能产生影响吗？

Q2.如果我使用引用传递它,那么对性能的影响应该是什么？

public void setAppLoginInformation(MyApplicationCtx &appObj){ …

说,我想创建一个File类

class File{
    public:
          File(const char *file){
               openFile(file);
          }
          ~File();
          isEmpty();
};

openFile检查文件是否存在或文件内容是否有效.

File *file = new File("filepath");
if(file)
file->isEmpty();

如果我的文件路径是正确的,那么所有正常的文件实例都是正确的,我们可以调用file->isEmpty(); 该文件不存在的内容,在这种情况下,检查结果仍为if(file)true,并将导致创建实际上无效的文件实例.如何保证如果文件路径无效,则文件实例应为null.

考虑两个班级

class A{
     public:
       A(){
       }
       ~A(){
       }
};


class AImpl : public A{
      public:
         AImpl(){
             a = new AInternal();
         }
         AImpl(AInternal *a){
             this->_a = a;
         }
         ~AImpl(){
             if(a){
                delete a;
                a = null;
             }
         }
       private:
             AInternal *a;
};

我试图隐藏AInternal的实现并只暴露A的接口.我在这里看到两件事

1. A级完全是空的.
2. 隐藏基本上是通过继承来实现的.我必须实际使用从A到AImpl的向下转换和向上转换,反之亦然.

这是一个很好的设计.由于缺乏设计经验,我看不出它的缺陷以及它为什么不好？