std::mutex::native_handle_type primitive()
 { return m.native_handle(); }

// Worker thread
static void networkThread(void)
{    
    HttpRequest *request = NULL;
    
    while (true) 
    {
        if (s_need_quit)
        {
            break;
        }
        
        // step 1: send http request if the requestQueue isn't empty
        request = NULL;
        
        s_requestQueueMutex.lock();
        
        //Get request task from queue
        
        if (0 != s_requestQueue->count())
        {
            request = dynamic_cast<HttpRequest*>(s_requestQueue->objectAtIndex(0));
            s_requestQueue->removeObjectAtIndex(0);
        }
        
        s_requestQueueMutex.unlock();
        
        if (NULL == request)
        {
            // Wait for http request tasks from main thread
            std::unique_lock<std::mutex> lk(s_SleepMutex); 
            s_SleepCondition.wait(lk);
            continue;
        }
        
        // step 2: libcurl sync access
        
        // Create a HttpResponse object, the default setting is http access failed
        HttpResponse *response = new HttpResponse(request);
        
        // request's refcount = 2 here, it's retained by HttpRespose constructor
        request->release();
        // ok, refcount = 1 now, only HttpResponse hold it.
        
        int32_t responseCode = -1;
        int retValue = 0;

        // Process the request -> get response packet
        switch (request->getRequestType())
        {
            case HttpRequest::kHttpGet: // HTTP GET
                retValue = processGetTask(request,
                                          writeData, 
                                          response->getResponseData(), 
                                          &responseCode,
                                          writeHeaderData,
                                          response->getResponseHeader());
                break;
            
            case HttpRequest::kHttpPost: // HTTP POST
                retValue = processPostTask(request,
                                           writeData, 
                                           response->getResponseData(), 
                                           &responseCode,
                                           writeHeaderData,
                                           response->getResponseHeader());
                break;

            case HttpRequest::kHttpPut:
                retValue = processPutTask(request,
                                          writeData,
                                          response->getResponseData(),
                                          &responseCode,
                                          writeHeaderData,
                                          response->getResponseHeader());
                break;

            case HttpRequest::kHttpDelete:
                retValue = processDeleteTask(request,
                                             writeData,
                                             response->getResponseData(),
                                             &responseCode,
                                             writeHeaderData,
                                             response->getResponseHeader());
                break;
            
            default:
                CCASSERT(true, "CCHttpClient: unkown request type, only GET and POSt are supported");
                break;
        }
                
        // write data to HttpResponse
        response->setResponseCode(responseCode);
        
        if (retValue != 0) 
        {
            response->setSucceed(false);
            response->setErrorBuffer(s_errorBuffer);
        }
        else
//.........这里部分代码省略.........

namespace clog {

std::mutex m;

struct logger2 {

	std::stringstream ss;
	const char *level;

	std::string now()
	{
		time_t t = time(NULL);
		struct tm *tm_info;
		tm_info = localtime(&t);

		char buf[20];
		strftime(buf, 20, "%F %T", tm_info);
		return std::string(buf);
	}

	logger2(const char *llevel)
	{
		level = llevel;
	}

	void flush(std::ostream &out)
	{
		m.lock();
		out << level << ": " << now() << " " 
			<< ss.str() << std::endl;
		m.unlock();
	}

	virtual ~logger2()
	{
	}

	template <typename t>
	logger2& operator<<(const t s)
	{
		ss << s;
		return *this;
	}
};

/* TODO Copy and pasted code. */
struct err : public logger2 {

	#ifdef CPP_LOG_ERR_FILE
	std::ofstream ofs;
	#endif

	err() : logger2("Error") {
		#ifdef CPP_LOG_ERR_FILE
		ofs.open(CPP_LOG_ERR_FILE, 
			std::ios_base::app | std::ios_base::out);
		#endif
	};

	~err() {
		#ifdef CPP_LOG_ERR_COUT
		flush(std::cout);
		#endif

		#ifdef CPP_LOG_ERR_CERR
		flush(std::cerr);
		#endif

		#ifdef CPP_LOG_ERR_FILE
		flush(ofs);
		ofs.close();
		#endif
	}
};

struct warn : public logger2 {

	#ifdef CPP_LOG_WARN_FILE
	std::ofstream ofs;
	#endif

	warn() : logger2("Warning") {
		#ifdef CPP_LOG_WARN_FILE
		ofs.open(CPP_LOG_WARN_FILE, 
			std::ios_base::app | std::ios_base::out);
		#endif
	};

	~warn() {
		#ifdef CPP_LOG_WARN_COUT
		flush(std::cout);
		#endif

		#ifdef CPP_LOG_WARN_CERR
		flush(std::cerr);
		#endif

		#ifdef CPP_LOG_WARN_FILE
		flush(ofs);
		ofs.close();
//.........这里部分代码省略.........

void withLock(std::mutex & m, Function f) {
  m.lock();
  f();
  m.unlock();
}

 void increment(){
     mutex.lock();
     counter.increment();
     mutex.unlock();
 }

 void add_inj(int other) {
     mutex.lock();
     inj.push_back(other);
     mutex.unlock();
 }

namespace bch {

class alignas(4) Test
{
public:
    Test()
    {
#if BCH_SMART_PTR_UNITTEST
        std::cout << "Test ctor(1)" << std::endl;
#endif
        Fill(1);
    }
    explicit Test(int v)
    {
#if BCH_SMART_PTR_UNITTEST
        std::cout << "Test ctor(2)" << std::endl;
#endif
        Fill(v);
    }
    ~Test()
    {
#if BCH_SMART_PTR_UNITTEST
        std::cout << "Test dtor" << std::endl;
#endif
    }
    
    void Baz()
    {
    }

private:
    void Fill(int v)
    {
        for (int i = 0; i < sizeof(mValue)/sizeof(*mValue); ++i)
            mValue[i] = v++;
    }
    char mValue[4];
};

class TestDer: public Test
{
public:
    TestDer()
    {
#if BCH_SMART_PTR_UNITTEST
        std::cout << "TestDer ctor" << std::endl;
#endif
    }
    ~TestDer()
    {
#if BCH_SMART_PTR_UNITTEST
        std::cout << "TestDer dtor" << std::endl;
#endif
    }
};

template <typename T>
void Foo(T value)
{
    value->Baz();
}

const unsigned int kTestCount = 100000000;
//    const unsigned int kTestCount = 1;

std::mutex mutex;
double stdPtrTime = 0;
double noThreadTime = 0;

void std_poiner()
{
    typedef std::chrono::time_point<std::chrono::system_clock> TimerType;
    TimerType start = std::chrono::system_clock::now();


    std::shared_ptr<Test> stdValue(new Test);
    for (unsigned int i = 0; i < kTestCount; ++i)
    {
        Foo(stdValue);
    }
    TimerType end = std::chrono::system_clock::now();
 
    std::chrono::duration<double> elapsed_seconds = end-start;

    double elapsed = elapsed_seconds.count();;
    {
        mutex.lock();
        stdPtrTime += elapsed;
        std::cout << "Time with std::shared_ptr is " << elapsed << std::endl;
        mutex.unlock();
    }
}

void nothread_poiner()
{
    typedef std::chrono::time_point<std::chrono::system_clock> TimerType;
    TimerType start = std::chrono::system_clock::now();

    shared_ptr_nc<Test> stdValue(new Test);
    for (unsigned int i = 0; i < kTestCount; ++i)
//.........这里部分代码省略.........

void func(int i) {
	mutex.lock();
	std::cout << "func clled, i = " << i << " /" << std::this_thread::get_id() << std::endl;
	mutex.unlock();
}

int main(int argc, char** argv)
{
  ros::init(argc, argv, "pathplanner");

  ros::NodeHandle nh;

  ros::Subscriber map_sub = nh.subscribe("/map", 1, map_callback);

  ros::Subscriber pose_sub = nh.subscribe("/odometry/filtered", 1, position_callback);

  ros::Subscriber waypoint_sub = nh.subscribe("/waypoint", 1, waypoint_callback);

  disp_path_pub = nh.advertise<nav_msgs::Path>("/path_display", 1);

  act_path_pub = nh.advertise<igvc_msgs::action_path>("/path", 1);

  expanded_pub = nh.advertise<pcl::PointCloud<pcl::PointXYZ>>("/expanded", 1);

  path_planner_map_pub = nh.advertise<pcl::PointCloud<pcl::PointXYZ>>("/path_planner_incremental", 1);

  double baseline = 0.93;

  ros::NodeHandle pNh("~");

  search_problem.Map = pcl::PointCloud<pcl::PointXYZ>().makeShared();
  search_problem.Map->header.frame_id = "/odom";
  search_problem.Octree = boost::make_shared<pcl::octree::OctreePointCloudSearch<pcl::PointXYZ>>(0.1);
  search_problem.Octree->setInputCloud(search_problem.Map);

  if (!pNh.hasParam("goal_threshold") || !pNh.hasParam("threshold") || !pNh.hasParam("speed") ||
      !pNh.hasParam("baseline") || !pNh.hasParam("minimum_omega") || !pNh.hasParam("maximum_omega") ||
      !pNh.hasParam("delta_omega") || !pNh.hasParam("point_turns_enabled") || !pNh.hasParam("reverse_enabled") ||
      !pNh.hasParam("max_obstacle_delta_t") || !pNh.hasParam("alpha") || !pNh.hasParam("beta") ||
      !pNh.hasParam("bounding_distance"))
  {
    ROS_ERROR_STREAM("path planner does not have all required parameters");
    return 0;
  }

  pNh.getParam("goal_threshold", search_problem.GoalThreshold);
  pNh.getParam("threshold", search_problem.Threshold);
  pNh.getParam("speed", search_problem.Speed);
  pNh.getParam("baseline", search_problem.Baseline);
  search_problem.DeltaT = [](double distToStart, double distToGoal) -> double {
    return -((distToStart + distToGoal) / 7 / (pow((distToStart + distToGoal) / 2, 2)) *
             pow(distToStart - (distToStart + distToGoal) / 2, 2)) +
           (distToStart + distToGoal) / 7 + 0.3;
  };
  pNh.getParam("minimum_omega", search_problem.MinimumOmega);
  pNh.getParam("maximum_omega", search_problem.MaximumOmega);
  pNh.getParam("delta_omega", search_problem.DeltaOmega);
  pNh.getParam("point_turns_enabled", search_problem.PointTurnsEnabled);
  pNh.getParam("reverse_enabled", search_problem.ReverseEnabled);
  pNh.getParam("max_obstacle_delta_t", search_problem.MaxObstacleDeltaT);
  pNh.getParam("alpha", search_problem.Alpha);
  pNh.getParam("beta", search_problem.Beta);
  pNh.getParam("bounding_distance", search_problem.BoundingDistance);

  ros::Rate rate(3);
  while (ros::ok())
  {
    ros::spinOnce();

    /* Do not attempt to plan a path if the path length would be greater than 100ft (~30m).
     * This should only happen when we have received either a waypoint or position estimate, but not both.
     * Long paths take forever to compute, and will freeze up this node.
     */
    auto distance_to_goal = search_problem.Start.distTo(search_problem.Goal);
    if (!received_waypoint || distance_to_goal == 0 || distance_to_goal > 60)
      continue;

    planning_mutex.lock();
    Path<SearchLocation, SearchMove> path;
    path = GraphSearch::AStar(search_problem, expanded_callback);
    if (act_path_pub.getNumSubscribers() > 0)
    {
      nav_msgs::Path disp_path_msg;
      disp_path_msg.header.stamp = ros::Time::now();
      disp_path_msg.header.frame_id = "odom";
      if (path.getStates()->empty())
        path.getStates()->push_back(search_problem.Start);
      for (auto loc : *(path.getStates()))
      {
        geometry_msgs::PoseStamped pose;
        pose.header.stamp = disp_path_msg.header.stamp;
        pose.header.frame_id = disp_path_msg.header.frame_id;
        pose.pose.position.x = loc.x;
        pose.pose.position.y = loc.y;
        disp_path_msg.poses.push_back(pose);
      }
      disp_path_pub.publish(disp_path_msg);
      igvc_msgs::action_path act_path_msg;
      act_path_msg.header.stamp = ros::Time::now();
      act_path_msg.header.frame_id = "odom";
      for (auto action : *(path.getActions()))
      {
        igvc_msgs::velocity_pair vels;
        vels.header.stamp = act_path_msg.header.stamp;
        vels.header.frame_id = act_path_msg.header.frame_id;
        if (action.W != 0)
//.........这里部分代码省略.........

//发送数据线程
void netSocketManger::sendThread()
{

    //bool connect = cSocket.Connect(kServerIP,kServerPort);
    bool connect = cSocket.Connect(netSocketManger::sharednetSocketManger()->server.IP.c_str(),netSocketManger::sharednetSocketManger()->server.port);
   // cSocket.Send("bbb",strlen("bbb")+1,0);

    if (connect) {
        isConnect = true;
        SocketData *errorData = newSocketData();
        errorData->eventType = CONNECT_SUCCEED;
        m_mainQueue.Push(errorData);
        //创建接收线程
        m_mutexx.lock();
        netSocketManger::sharednetSocketManger()->createReciveThread();
        m_mutexx.unlock();
        m_sendEvent->Lock();
        while (true) {
            while (!m_sendQueue.IsEmpty()) {
                SocketData *data = m_sendQueue.Pop();
                uLong comprLen = data->bodyLen;
                const char *compr = data->sendData;
                
                T_MSGHEAD_T msgHead;
                
                msgHead.cmd = (unsigned short)data->module.cmd;
                msgHead.com = 0;
                msgHead.enc = 0;
                msgHead.eno = 0;
                msgHead.idx = (uInt)data->sn;
                msgHead.len = (unsigned short)comprLen;
                msgHead.tea = 0;//s_tea;
                
                unsigned char *sendData = (unsigned char*)malloc(comprLen);
                unsigned int pos = 0;
                
                memcpy(&sendData[pos], compr, comprLen);//body
                pos += comprLen;
                
                int ret = cSocket.Send((char*)sendData,pos,0);
                log("发送:%s",compr);
                if (ret <= 0) {
                    m_sendEvent->Unlock();
                    free(sendData);
                    SocketData *errorData = newSocketData();
                    errorData->eventType = DISCONNECT;
                    m_mainQueue.Push(errorData);
                    return;
                }

                free(data->sendData);
                free(data);
                free(sendData);

                log("-----发送数据长度len:%d------",msgHead.len);
                log("-----------");
                
            }
            
            m_sendEvent->Wait();
        }
        m_sendEvent->Unlock();
    }else {
        isConnect = false;
        SocketData *errorData = newSocketData();
        errorData->eventType = CONNECT_FAIL;
        m_mainQueue.Push(errorData);
    }
}

 void add_adj(int other) {
     mutex.lock();
     adj.push_back(other);
     mutex.unlock();
 }

namespace BB
{

// Global variable for now
std::mutex boundTightenerMutex;

OBBT::OBBT(double threshold, unsigned int maxIterations)
    : BoundsTightener(threshold, maxIterations),
      doParallelComputing(false),
      doAggressiveBoundsTightening(false)
{
}

bool OBBT::doTightening(ConstraintPtr constraints)
{
    // Get convex relaxation
    ConstraintPtr convexConstraints = constraints->getConvexRelaxation();

    assert(convexConstraints != nullptr);
    assert(convexConstraints->isConstraintConvex());

    // Tighten bounds of all complicating variables
    std::vector<VariablePtr> variables;
    for (auto var : constraints->getComplicatingVariables())
    {
        if (assertNear(var->getUpperBound(), var->getLowerBound()))
            continue;

        variables.push_back(var);
    }

    // Check if there are any variables to tighten
    if (variables.size() < 1)
        return true;

    // Tighten bounds
    return tightenBoundsSequential(convexConstraints, variables);
//    bool success = true;

//    if (doParallelComputing)
//    {
//        tightenBoundsParallel(convexConstraints, variables);
//    }
//    else
//    {
//        success = tightenBoundsSequential(convexConstraints, variables);
//    }

//    return success;
}

bool OBBT::tightenBoundsSequential(ConstraintPtr cs, std::vector<VariablePtr> variables)
{
    for (auto var : variables)
    {
        // Tighten bounds of single variable
        if (!tightenVariableBound(cs, var))
            return false;
    }

    return true;
}

void OBBT::tightenBoundsParallel(ConstraintPtr cs, std::vector<VariablePtr> variables)
{
    assert(variables.size() > 0);

    std::vector<std::thread> threads;
    int numThreads = std::thread::hardware_concurrency();
    if (numThreads < 1) numThreads = 1;

    int varsPerThread = variables.size()/numThreads;

//    printVec(variables);
//    cout << "Variables: " << variables.size() << endl;
//    cout << "Threads: " << numThreads << endl;

    for (int i = 0; i < numThreads; i++)
    {
        int start = i*varsPerThread;
        int end = (i+1)*varsPerThread;
        if (i == numThreads - 1) end = variables.size();

        //cout << "Thread " << i << ": " << start << " to " << end << endl;

        std::vector<VariablePtr>::const_iterator varStart = variables.begin() + start;
        std::vector<VariablePtr>::const_iterator varEnd = variables.begin() + end;
        std::vector<VariablePtr> threadVariables(varStart, varEnd);
        //printVec(threadVariables);

        threads.push_back(std::thread(&OBBT::tightenVariableBounds, this, cs, threadVariables));
//        threads.push_back(thread(&BoundTightener::test, this, convexConstraints, z0_aug, ref(threadVariables)));
    }

    for (int i = 0; i < numThreads; i++)
    {
        threads.at(i).join();
    }
}

//.........这里部分代码省略.........

void network()
{
  ENetAddress address;
  ENetHost* client;
  ENetPeer* peer;
  std::string message;
  ENetEvent event;
  int eventStatus;

  if (enet_initialize () != 0)
  {	
  		std::cout << "Could not start ENet." << std::endl;
      return;
  }else
  	std::cout << "Started ENet." << std::endl; 
  atexit(enet_deinitialize);

  client = enet_host_create(NULL, 1, 2, 57600 / 8, 14400 / 8);

  enet_address_set_host(&address, "localhost");
  char hej[10];
  enet_address_get_host(&address, hej, 10);
  std::cout << hej << std::endl;
  address.port = 1234;
  

  peer = enet_host_connect(client, &address, 2, 0);

  while(true)
  {
    while (enet_host_service(client, &event, 1000) > 0)
    {
      switch (event.type)
      {
      case ENET_EVENT_TYPE_CONNECT:
        std::cout << "We got a new connection " << event.peer->address.host << std::endl;
        break;

      case ENET_EVENT_TYPE_RECEIVE:
      {
          std::cout << "Message from servv: ";
          //enet_peer_disconnect(peer, 3);
          char header[] = {((char*) event.packet->data)[0],
                            ((char*) event.packet->data)[1],
                            ((char*) event.packet->data)[2],
                            ((char*) event.packet->data)[3]};
          int* headerInt = (int*) header;
          std::cout << *headerInt << std::endl;

          if (*headerInt == PLAYER_POSITION)
          {
            Package<PLAYER_POSITION_TYPE>* message = (Package<PLAYER_POSITION_TYPE>*) event.packet->data;
            std::cout << "player: " << message->_player << std::endl;
            std::cout << "x: " << message->_data.x << std::endl;
            std::cout << "y: " << message->_data.y << std::endl;
            std::cout << "z: " << message->_data.z << std::endl;
          }else if (*headerInt == ASSIGN_PLAYER_NUMBER)
          {
            Package<int>* message = (Package<int>*) event.packet->data;
            std::cout << "Player number: " << message->_data << std::endl;
          }
          
          // int message = ((char*) event.packet->data)
          enet_packet_destroy(event.packet);
        
        

        break;
      }
      case ENET_EVENT_TYPE_DISCONNECT:
        
        std::cout << "Disconnected from serv: " << event.peer->data << std::endl;
        event.peer->data = NULL;
        break;
      }
    }

    posMutex.lock();
    glm::vec3 hej = pos;
    posMutex.unlock();
    // std::cout << "Position sent: (" << hej.x << ", " << hej.y << ", " << hej.x << ")" << std::endl;
    ENetPacket* packet = enet_packet_create(&hej, sizeof(glm::vec3), ENET_PACKET_FLAG_RELIABLE);
    enet_peer_send(peer, 0, packet);

    std::cout << "ping: " << peer->roundTripTime << " ms" << std::endl;
		offMutex.lock();
    if (turnOfNetwork)
    {
    	offMutex.unlock();
    	std::cout << "Network recived shoudown command." << std::endl;
    	break;
    }else
    	offMutex.unlock();
  }
  std::cout << "Turning of network." << std::endl;

  enet_host_destroy(client);
}

 void lock()
 { m.lock(); }

int main(){
	Uavcam *camera; 
 	bool camera_ok, frame_ok;
	int n_saved;
	
	std::stringstream filename;
	std::stringstream directory;

	std::vector<int> jpg_params;
	cv::Mat frame, preview;

	parseConfig();
	jpg_params.push_back(CV_IMWRITE_JPEG_QUALITY);
	jpg_params.push_back(90);

	//Set Signals
	std::signal(SIGINT,exit_signal); 	//Set up Ctrl+C signal

	//Construct Cameras
	if (cameratype == 1){
#ifdef USE_ARAVIS
		camera = new AravisCam();
		std::cout<<"Using Aravis camera"<<std::endl;
#else
		camera = new WebCam();
#endif
	}
	
	if(view)	
		cv::namedWindow("Camera Viewer", cv::WINDOW_AUTOSIZE);
	
	n_saved = checkLog(); 			//Check the log and open it
	openLogtoWrite(n_saved);

	ublox = new Gps();			//Initialize the GPS
	std::thread gps_thread(gpsUpdate);
	
	camera_ok = camera->initializeCam();  	//Initialize the camera

	if (camera_ok) {

		std::cout << "Start camera acquisition in " << start_delay << " seconds" << std::endl;
		std::this_thread::sleep_for(std::chrono::seconds(start_delay));	

		while(!finish){  //--Main Acquisition Loop

			filename.str(""); directory.str(""); //Update filenames
			filename<<"im"<<std::setfill('0')<<std::setw(4)<<++n_saved<<".jpg";
			directory<<FOLDER<<filename.str();
		
			camera->trigger(); //Send camera trigger

			if (usegps){
				if(ublox->data_is_good)	
					std::cout<<"GPS up to date"<<std::endl;
				else	
					std::cout<<"No GPS available" <<std::endl;
			}
			mtx.lock();
			writeImageInfo(ublox->current_loc, filename.str()); //Record GPS 
			mtx.unlock();

			frame_ok = camera->getImage(frame); //Acquire the image

			if(frame_ok){ //Acquired Image

				cv::resize(frame,preview,cv::Size(),sizefac,sizefac,cv::INTER_NEAREST);

				if(saveimg) {
					cv::imwrite(directory.str(), preview, jpg_params);
					std::cout<<"Saved to " << filename.str() <<std::endl;
				}

				if(view) {
					cv::imshow("Camera Viewer", preview); 
					cv::waitKey(50);
				}	
			}
			
			std::this_thread::sleep_for(std::chrono::milliseconds(250));
		} 
		//Finished photographing
		delete camera;
	}

	gps_thread.join();
	closeLog();

	return 0;
}

int main(int argc, const char* argv[])
{
	#ifdef _WIN32
		//Start up Winsock…
		WSADATA wsadata;

		int error = WSAStartup(0x0202, &wsadata);
		if (error)	//Did something happen?
		{
			std::cerr<<"Unable to start winsock"<<std::endl;
			return -1;
		}

		if (wsadata.wVersion != 0x0202)//Did we get the right Winsock version?
		{
			Die("version mismatch");
		}
	#endif


	std::cout << "Enter Server URL: ";
	char url[0x100];
	std::cin.getline(url,sizeof(url));

	std::cout << "Enter your Nickname: ";
	char nickname[0x100] = ":";
	std::cin.getline(nickname+1,sizeof(nickname)-1);

	char*colon = strchr(url,':');
	std::string surl,sport;
	
	if (colon != NULL)
	{
		*colon = 0;
		sport = colon+1;
	}
	else
	{
		sport = ToString(DEFAULT_PORT);
	}
	surl = url;
	
	PrintLine("Attempting to connect to "+surl);

	ADDRINFOA hints;
	memset(&hints,0,sizeof(hints));
	hints.ai_protocol = IPPROTO_TCP;
    hints.ai_family = AF_UNSPEC;
	//hints.
	ADDRINFOA*result;
	if (getaddrinfo(surl.c_str(),sport.c_str(),&hints,&result) != 0)
	{
		Die("Call to getaddrinfo() failed");
	}

	bool connected = false;
	while (result)		//search through all available results until one allows connection. 
						//Chances are we get IPv4 and IPv6 results here but the server will only answer to one of those
	{
		sock = socket(result->ai_family,result->ai_socktype,result->ai_protocol);
		if (sock != INVALID_SOCKET)	//if we can create a socket then we can attempt a connection. It would be rather unusual for this not to work but...
		{
			if (!connect(sock,result->ai_addr,result->ai_addrlen))	//attempt connnection
			{
				//connected
				PrintLine("Connected to "+ToString(*result));	//yay, it worked
				connected = true;
				break;
			}
			else
			{
				closesocket(sock);		//these aren't the droids we're looking for.
				sock = INVALID_SOCKET;
			}

		}
		
		result = result->ai_next;	//moving on.
	}
	if (!connected)
		Die("Failed to connect to "+surl+":"+sport);	//so, yeah, none of them worked.

	Submit(nickname);	//includes leading ':', so that the server knows this is a name, not a message

	netThread = std::thread(NetLoop);	//start read-thread
	
	while (sock != INVALID_SOCKET)
	{
		char c = _getch();	//keep reading characters
		{
			if (c == 3)	//this only works on windows, but ctrl-c is handled better on linux anyway
			{
				Die("Ctrl+C");
				break;
			}
			consoleLock.lock();
			if (c == '\n' || c == '\r')							//user pressed enter/return:
			{
				std::string submit = inputBuffer;				//copy buffer to string
				std::cout << '\r';								//move cursor to line beginning
//.........这里部分代码省略.........

void gl::globalRelease(bool finish) {
    if (finish) {
        glFinish();
    }
    _globalOpenGLLock.unlock();
}

	static void log(const std::stringstream &message) {
		m.lock();
		std::cout << message.str() << std::endl << std::flush;
		m.unlock();
	}

void CommandReceiver::addCommands(const vector<Command>& commands) {

    m_stackLock.lock();
    m_commandStack.insert(m_commandStack.end(), commands.begin(), commands.end());
    m_stackLock.unlock();
}

void lockScripts()
{
	scriptLock.lock();
}