Multithreading in C++ is a technique that enables a C++ application to concurrently execute multiple threads. This approach enhances the performance and parallel processing capabilities of applications. Introduced with C++11, it simplifies thread creation and management for developers. In this article, we will explore the concept of multithreading, define a thread, demonstrate thread creation, discuss the advantages of multithreading, its lifecycle, challenges, real-world applications, and optimal practices in C++.
Multithreading in C++ denotes a program’s capability to run multiple threads or code segments simultaneously or concurrently. This not only boosts performance on multi-core processors but also maintains application responsiveness. However, it can also introduce challenges such as deadlock, race conditions, and intricate debugging processes.
With the arrival of C++11, integrated support for multithreading was provided via libraries like <thread>, <mutex>, among others.
Key Benefits of Multithreading in C++
Enhanced Performance: It enables a program to utilize multiple cores, resulting in quicker execution.
Resource Optimization: Threads share the same memory space as a process, minimizing memory overhead.
Scalability: Multithreading allows applications to better scale across multi-core platforms.
Asynchronous Operations: It permits various programs to execute background tasks, such as file downloads, without hindering the primary process.
Improved Responsiveness: In applications such as GUIs or games, it sustains program interactivity.
What is a Thread?
A thread is the most basic unit of execution within a program. When a program is executed, the operating system allocates it a process, which can contain several threads, each handling distinct tasks simultaneously.
Programs can be categorized into two types: single-threaded and multi-threaded:
Single-threaded Program: Only one task is executed at any given moment.
Multi-threaded Program: Multiple tasks can be executed concurrently.
Creating a Thread in C++
A thread can be instantiated using the std::thread class from the <thread> header. To initiate a thread, simply create a std::thread object and provide a callable, like a function or a functor, to the object’s constructor. This action will immediately spawn a new thread to execute the specified callables in parallel with the main thread.
Syntax:
std::thread thread_object(callable);
In this instance,
std::thread – It represents a thread class in the C++ Standard Library.
thread_object – This denotes the name of the newly created thread.
callable – It can be a function, lambda expression, or any callable object.
Example:
Cpp
Code Copied!
var isMobile = window.innerWidth;
“““javascript
let isMobile = window.innerWidth “”);
editor23113.setValue(decodedContent); // Set initial text
editor23113.clearSelection();
editor23113.setOptions({
maxLines: Infinity
});
function decodeHTML23113(input) {
var doc = new DOMParser().parseFromString(input, “text/html”);
return doc.documentElement.textContent;
}
// Function to copy code to clipboard
function copyCodeToClipboard23113() {
const code = editor23113.getValue(); // Retrieve code from the editor
navigator.clipboard.writeText(code).then(() => {
jQuery(“.maineditor23113 .copymessage”).show();
setTimeout(function() {
jQuery(“.maineditor23113 .copymessage”).hide();
}, 2000);
}).catch(err => {
console.error(“Error copying code: “, err);
});
}
function runCode23113() {
var code = editor23113.getSession().getValue();
jQuery.ajax({
url: “https://intellipaat.com/blog/wp-admin/admin-ajax.php”,
type: “post”,
data: {
language: “cpp”,
code: code,
cmd_line_args: “”,
variablenames: “”,
action:”compilerajax”
},
success: function(response) {
var myArray = response.split(“~”);
var data = myArray[1];
jQuery(“.output23113”).html(“
"+data+"");
jQuery(".maineditor23113 .code-editor-output").show();
jQuery("#runBtn23113 i.run-code").hide();
}
});
}
function closeOutput23113() {
var code = editor23113.getSession().getValue();
jQuery(".maineditor23113 .code-editor-output").hide();
}
// Add event listeners to the buttons
document.getElementById("copyBtn23113").addEventListener("click", copyCodeToClipboard23113);
document.getElementById("runBtn23113").addEventListener("click", runCode23113);
document.getElementById("closeoutputBtn23113").addEventListener("click", closeOutput23113);
Output:
This code illustrates how to create a thread that executes the sayHello function, outputs “Hello from the thread!”, and subsequently waits for the thread to finish with t.join() before displaying “Hello from the main function!” in the primary thread.
Defining the Callable in C++
A callable in C++ refers to either a function or an object that gets executed upon the thread's initiation. It is provided to a thread constructor, and it can be a function pointer, lambda expression, functor, or either a non-static or a static member function.
Let's briefly explore each type of callable with examples in C++.
1. Function Pointer
A function pointer denotes a pointer that targets a function. It can signify a function and be passed to a thread for execution. You simply define a standard function, pass its name as a pointer to std::thread, and it will execute in a separate thread upon the thread's commencement.
Example:
Cpp
Code Copied!
Output:
The snippet demonstrates how the std::thread t(sayHello) is utilized to initiate a thread that invokes the sayHello function. The t.join() ensures that the main thread pauses until t concludes, after which the outcome appears in the console.
2. Lambda Expression
A lambda expression represents an unnamed function that is declared inline within the code. It can be specified directly at the point of invocation, rendering it highly adaptable. The lambda can capture variables from its enclosing environment, can be passed immediately into std::thread, and will be executed by the new thread.
Example:
Cpp
Code Copied!
Output:
The snippet illustrates how a thread is established using a lambda expression that outputs “Hello from the lambda thread!” and also awaits the completion of the thread via t.join().
3. Function Object (Functor)
A functor is an object that can be invoked like a function. Functors can possess state, making them advantageous when an object requires specific behavior or internal information. Define a class (or struct) that overrides the operator(), create an instance of this class, and supply it to std::thread. The object is executed by the thread just as if it were a function.
Example:
Cpp
Code Copied!
Output:
The code demonstrates how a thread is established by passing a functor object, MyTask, which specifies the task to be performed, and waits for the thread to finalize using t.join().
4. Non-Static Member Function
A non-static member function is associated with a particular instance of a class. It requires an object for invocation. Therefore, to execute a non-static member function within a thread, both the member function pointer and the object instance must be provided to std::thread.
Example:
Cpp
Code Copied!
Output:
``````html
The snippet illustrates how a thread is initiated, which is employed to execute a non-static member function, sayHello, on an object obj, and also awaits the thread's completion utilizing t.join(). Subsequently, the output is displayed in the console.
5. Static Member Function
A static member function is a function that is associated with the class itself instead of any class object, allowing it to be directly handed to std::thread without requiring any object instance.
Illustration:
Cpp
Code Copied!
Output:
The snippet demonstrates how a thread is initiated, which is utilized to invoke the static member function sayHello directly without any object instance, and then waits for the thread to conclude using t.join(), and thereafter the message is displayed in the console.
Thread Lifecycle in C++
The thread lifecycle encompasses the progression through various phases that a thread experiences during program execution, from its initiation to its cessation.
Phases of a C++ Thread Lifecycle:
Phase
Description
New
A thread object is established, but no execution thread has commenced yet.
Runnable
When a thread begins, it is set to run or is already in execution.
Running
The thread is actively carrying out its designated function.
Blocked / Waiting
A thread may pause, waiting for I/O, synchronization, or some event (such as join()).
Terminated / Dead
A thread concludes execution or is halted, and it cannot be restarted.
Illustration:
Cpp
Code Copied!
``````html
"");
editor46018.setValue(decodedContent); // Establish the default text
editor46018.clearSelection();
editor46018.setOptions({
maxLines: Infinity
});
function decodeHTML46018(input) {
var doc = new DOMParser().parseFromString(input, "text/html");
return doc.documentElement.textContent;
}
// Function to copy code to clipboard
function copyCodeToClipboard46018() {
const code = editor46018.getValue(); // Retrieve code from the editor
navigator.clipboard.writeText(code).then(() => {
// alert("Code copied to clipboard!");
jQuery(".maineditor46018 .copymessage").show();
setTimeout(function() {
jQuery(".maineditor46018 .copymessage").hide();
}, 2000);
}).catch(err => {
console.error("Error copying code: ", err);
});
}
function runCode46018() {
var code = editor46018.getSession().getValue();
jQuery("#runBtn46018 i.run-code").show();
jQuery(".output-tab").click();
jQuery.ajax({
url: "https://intellipaat.com/blog/wp-admin/admin-ajax.php",
type: "post",
data: {
language: "cpp",
code: code,
cmd_line_args: "",
variablenames: "",
action:"compilerajax"
},
success: function(response) {
var myArray = response.split("~");
var data = myArray[1];
jQuery(".output46018").html("
"+data+"");
jQuery(".maineditor46018 .code-editor-output").show();
jQuery("#runBtn46018 i.run-code").hide();
}
});
}
function closeOutput46018() {
var code = editor46018.getSession().getValue();
jQuery(".maineditor46018 .code-editor-output").hide();
}
// Attach event listeners to the buttons
document.getElementById("copyBtn46018").addEventListener("click", copyCodeToClipboard46018);
document.getElementById("runBtn46018").addEventListener("click", runCode46018);
document.getElementById("closeoutputBtn46018").addEventListener("click", closeOutput46018);
Output:
The program illustrates how a thread is initiated to execute the task function, waits for its completion via t.join(), and subsequently displays a message from the main thread upon the conclusion of the thread lifecycle.
Thread Control in C++
Thread control in C++ pertains to managing the execution of threads. This includes spawning threads, awaiting their completion, allowing independent execution, determining joinability, and managing their IDs. In C++, threads are regulated through the <thread> header, which oversees the entire lifecycle of threads.
Essential Thread Control Functions:
Function
Description
join()
Halts the calling thread until the associated thread completes execution.
detach()
Permits the thread to operate independently, reclaiming resources once it concludes.
joinable()
Returns true if the thread is joinable or detachable, preventing errors.
get_id()
Returns the unique identifier of the thread.
hardware_concurrency()
Returns the optimal number of concurrent threads the system can handle.
Illustration:
Cpp
Code Copied!
Result:
The sample demonstrates how a thread is spawned to execute the task function, verifying if the thread is joinable, waiting for it using t.join(), and then outputs a message from the main thread following the completion of the thread.
Challenges with Multithreading in C++
Below are several common challenges associated with multithreading in C++:
Deadlocks: A deadlock arises when two or more threads are waiting for one another to free resources, resulting in threads that remain frozen indefinitely.
Thread Contention: This occurs when multiple threads desire the same resource, potentially causing performance slowdowns.
Race Conditions: A race condition takes place when a thread's behavior varies based on the sequence and timing of events, leading to erratic behavior depending on the timing and order.
Thread Leaks: This refers to instances where a thread is neither properly joined nor detached, resulting in threads that are inactive yet still consuming resources.
Thread Safety Issues: Non-thread-safe libraries and functions can create complications when accessed by multiple threads simultaneously.
Starvation: Starvation happens when threads are unable to acquire resources because other threads are utilizing them.
Thread Synchronization in C++
Thread synchronization is crucial for regulating access to shared resources among multiple threads. It ensures that threads do not conflict with each other while accessing or modifying shared data and mitigates problems like data races and race conditions.
Forms of Synchronization in C++
1. Mutexes (Mutual Exclusion)
A mutex acts as a lock used to secure shared data from simultaneous access by multiple threads. Only one thread may hold and utilize the mutex at any given time, guaranteeing exclusive access.
Example:
Cpp
Code Copied!
Result:
``````html
The snippet illustrates the utilization of std::mutex and std::lock_guard to increment a shared resource counter within a multithreaded setting, ensuring that only one thread can access and alter the counter simultaneously.
2. std::lock_guard and std::unique_lock
These represent RAII-style locks that administer mutexes.
std::lock_guard: It automatically acquires the mutex at the moment of creation and releases it when the scope of the lock is exited.
std::unique_lock: It offers greater flexibility than std::lock_guard, permitting manual locking and unlocking, and can be employed with std::condition_variable.
Illustration:
Cpp
Code Copied!
Result:
The snippet demonstrates how std::lock_guard and std::unique_lock are employed to increment a shared variable counter, which efficiently manages the locking and unlocking of a mutex to avert race conditions, with the ultimate counter value displayed in the console.
3. Condition Variables
Condition variables are utilized for thread synchronization, as they wait until a specific condition is met. They are always combined with a mutex and are useful when one thread must wait for another to complete a task.
Illustration:
Cpp
Code Copied!
``````javascript
isMobile = window.innerWidth ");
editor51472.setValue(decodedContent); // Assign the default text
editor51472.clearSelection();
editor51472.setOptions({
maxLines: Infinity
});
function decodeHTML51472(input) {
var doc = new DOMParser().parseFromString(input, "text/html");
return doc.documentElement.textContent;
}
// Function to copy code to clipboard
function copyCodeToClipboard51472() {
const code = editor51472.getValue(); // Retrieve code from the editor
navigator.clipboard.writeText(code).then(() => {
// alert("Code copied to clipboard!");
jQuery(".maineditor51472 .copymessage").show();
setTimeout(function() {
jQuery(".maineditor51472 .copymessage").hide();
}, 2000);
}).catch(err => {
console.error("Error copying code: ", err);
});
}
function runCode51472() {
var code = editor51472.getSession().getValue();
function closeoutput51472() {
var code = editor51472.getSession().getValue();
jQuery(".maineditor51472 .code-editor-output").hide();
}
// Attach event listeners to the buttons
document.getElementById("copyBtn51472").addEventListener("click", copyCodeToClipboard51472);
document.getElementById("runBtn51472").addEventListener("click", runCode51472);
document.getElementById("closeoutputBtn51472").addEventListener("click", closeoutput51472);
Output:
The snippet illustrates how the std::condition_variable enables one thread to wait until the condition ready == true is satisfied, while another thread sets this condition and notifies the waiting thread to proceed.
4. Read-Write Locks
A read-write lock permits multiple threads to access shared data concurrently, however, it provides exclusive access to write operations. This mechanism is optimal when the system has numerous readers and minimal writers.
Example:
Cpp
Code Copied!
var isMobile = window.innerWidth ");
editor1831.setValue(decodedContent); // Set the initial text
editor1831.clearSelection();
editor1831.setOptions({
maxLines: Infinity
});
function decodeHTML1831(input) {
var doc = new DOMParser().parseFromString(input, "text/html");
return doc.documentElement.textContent;
}
// Function to copy code to clipboard
function copyCodeToClipboard1831() {
const code = editor1831.getValue(); // Get code from the editor
navigator.clipboard.writeText(code).then(() => {
// alert("Code copied to clipboard!");
jQuery(".maineditor1831 .copymessage").show();
setTimeout(function() {
jQuery(".maineditor1831 .copymessage").hide();
}, 2000);
}).catch(err => {
console.error("Error copying code: ", err);
});
}
function runCode1831() {
var code = editor1831.getSession().getValue();
function closeoutput1831() {
var code = editor1831.getSession().getValue();
jQuery(".maineditor1831 .code-editor-output").hide();
}
// Link event listeners to the buttons
document.getElementById("copyBtn1831").addEventListener("click", copyCodeToClipboard1831);
document.getElementById("runBtn1831").addEventListener("click", runCode1831);
document.getElementById("closeoutputBtn1831").addEventListener("click", closeoutput1831);
Result:
The snippet illustrates how std::shared_mutex is implemented in the C++ code, where read_data acquires a shared lock enabling multiple readers, while write_data secures an exclusive lock for safe writing. This mechanism guarantees proper synchronization between reading and writing operations.
Terminating Threads in C++
Threads in C++ conclude automatically once their function execution is complete. The termination can be managed explicitly using join() to wait for the thread or detach() to allow it to operate independently. If a thread remains unjoined or detached prior to destruction, std::terminate() is invoked, leading to an abrupt program halt. Hence, it is essential to verify that the thread is joinable before performing join or detach operations.
Illustration:
Cpp
Code Copied!
var isMobile = window.innerWidth ");
editor65283.setValue(decodedContent); // Set the initial text
editor65283.clearSelection();
editor65283.setOptions({
maxLines: Infinity
});
function decodeHTML65283(input) {
var doc = new DOMParser().parseFromString(input, "text/html");
return doc.documentElement.textContent;
}
// Utility function to copy code to clipboard
function copyCodeToClipboard65283() {
const code = editor65283.getValue(); // Fetch code from the editor
navigator.clipboard.writeText(code).then(() => {
// alert("Code copied to clipboard!");
function closeoutput65283() {
var code = editor65283.getSession().getValue();
jQuery(".maineditor65283 .code-editor-output").hide();
}
// Link event listeners to the buttons
document.getElementById("copyBtn65283").addEventListener("click", copyCodeToClipboard65283);
document.getElementById("runBtn65283").addEventListener("click", runCode65283);
document.getElementById("closeoutputBtn65283").addEventListener("click", closeoutput65283);
Result:
This code snippet demonstrates how to correctly terminate a thread by verifying that it is joinable before invoking join(), thereby preventing possible errors. Following that, the output is displayed to the console.
Joining and Detaching Threads in C++
Joining (join()): The join() method halts the calling or main thread until the target thread completes its work. It confirms that the thread has finalized its task before the program can continue.
Detaching (detach()): The detach() method allows a thread to execute independently. Once detached, it cannot be joined again, and its resources are cleaned up automatically upon completion.
Illustration:
Cpp
Code Copied!
``````html
var isMobile = window.innerWidth ");
editor92043.setValue(decodedContent); // Set the initial text
editor92043.clearSelection();
editor92043.setOptions({
maxLines: Infinity
});
function decodeHTML92043(input) {
var doc = new DOMParser().parseFromString(input, "text/html");
return doc.documentElement.textContent;
}
// Function to copy code to clipboard
function copyCodeToClipboard92043() {
const code = editor92043.getValue(); // Retrieve code from the editor
navigator.clipboard.writeText(code).then(() => {
// alert("Code has been copied to clipboard!");
function closeoutput92043() {
var code = editor92043.getSession().getValue();
jQuery(".maineditor92043 .code-editor-output").hide();
}
// Attach event listeners to the buttons
document.getElementById("copyBtn92043").addEventListener("click", copyCodeToClipboard92043);
document.getElementById("runBtn92043").addEventListener("click", runCode92043);
document.getElementById("closeoutputBtn92043").addEventListener("click", closeoutput92043);
Output:
The code illustrates how the t1.join() halts the main thread until t1 finishes executing, while t2.detach() removes the thread, allowing it to run in the background independently without synchronization, and subsequently outputs to the console.
Context Switching in Multithreading in C++
When the CPU transitions from one active thread to another, it is referred to as a context switch in multithreading. During a context switch, the system saves the state of the currently running thread and then loads the next thread’s state, allowing it to continue execution in its typical sequence without issues.
Example:
Cpp
Code Copied!
var isMobile = window.innerWidth ");
editor74661.setValue(decodedContent); // Set the initial text
editor74661.clearSelection();
editor74661.setOptions({
maxLines: Infinity
});
function decodeHTML74661(input) {
var doc = new DOMParser().parseFromString(input, "text/html");
return doc.documentElement.textContent;
}
// Function to copy code to clipboard
function copyCodeToClipboard74661() {
const code = editor74661.getValue(); // Retrieve code from the editor
navigator.clipboard.writeText(code).then(() => {
// alert("Code has been copied to clipboard!");
data: {
language: "cpp",
code: code,
cmd_line_args: "",
variablenames: "",
action:"compilerajax"
},
success:
``````javascript
function(response) {
var myArray = response.split("&");
var data = myArray[1];
jQuery(".output74661").html("
" + data + """);
jQuery(".maineditor74661 .code-editor-output").show();
jQuery("#runBtn74661 i.run-code").hide();
}
function closeoutput74661() {
var code = editor74661.getSession().getValue();
jQuery(".maineditor74661 .code-editor-output").hide();
}
// Bind event listeners to the buttons
document.getElementById("copyBtn74661").addEventListener("click", copyCodeToClipboard74661);
document.getElementById("runBtn74661").addEventListener("click", runCode74661);
document.getElementById("closeoutputBtn74661").addEventListener("click", closeoutput74661);
Result:
The script illustrates how task1 and task2 execute concurrently using distinct threads, simulate processing via sleep_for, and synchronize their completion through join() to guarantee both wrap up before the program terminates.
Transmitting Arguments to Threads in C++
In C++, arguments are handed over to a thread function merely by supplying them subsequent to the function name at the moment the std::thread object is instantiated. The thread constructor intuitively relays the arguments to the callable.
Illustration:
Cpp
Code Copied!
var isMobile = window.innerWidth "");
editor99182.setValue(decodedContent); // Set the initial text
editor99182.clearSelection();
editor99182.setOptions({
maxLines: Infinity
});
function decodeHTML99182(input) {
var doc = new DOMParser().parseFromString(input, "text/html");
return doc.documentElement.textContent;
}
// Function to duplicate code to clipboard
function copyCodeToClipboard99182() {
const code = editor99182.getValue(); // Retrieve code from the editor
navigator.clipboard.writeText(code).then(() => {
jQuery(".maineditor99182 .copymessage").show();
setTimeout(function() {
jQuery(".maineditor99182 .copymessage").hide();
}, 2000);
}).catch(err => {
console.error("Error duplicating code: ", err);
});
}
function runCode99182() {
var code = editor99182.getSession().getValue();
function closeoutput99182() {
var code = editor99182.getSession().getValue();
jQuery(".maineditor99182 .code-editor-output").hide();
}
// Bind event listeners to the buttons
document.getElementById("copyBtn99182").addEventListener("click", copyCodeToClipboard99182);
document.getElementById("runBtn99182").addEventListener("click", runCode99182);
document.getElementById("closeoutputBtn99182").addEventListener("click", closeoutput99182);
Result:
The sample demonstrates the method of passing arguments to a thread function by value, where the string “Intellipaat” is forwarded to the greet function executing within a distinct thread.
Multiprocessing versus Multithreading in C++
Characteristic
Multiprocessing
Multithreading
Explanation
Facilitates the execution of multiple processes
Enables concurrent execution of multiple threads within a single process
Memory Allocation
Each process operates within its own memory zone
Threads utilize the same memory zone
Communication Speed
Slower
Quicker, due to shared memory
Resource Overhead
Significant
Minimal
Impact of Failure
A failure in one process has no effect on others
A thread failure can cause the entire process to crash
Applications
High CPU-intensive tasks, genuine parallelism
I/O-intensive tasks, lightweight parallelism
Practical Uses for Multithreading in C++
Multithreading finds application in game creation, enhancing the performance of games.
It allows a...
``````html
A server designed to accommodate numerous user requests simultaneously.
Multithreading improves efficiency by processing data, allowing you to split tasks and tackle them concurrently.
It supports continuous monitoring and data processing from sensors with minimal latency.
Multithreading enables video and audio operations to function independently, ensuring a seamless application experience.
It also aids in the immediate processing of transactions and promotes quicker decision-making.
Training AI models becomes more efficient as calculations can be distributed, and additional parallel threads can operate with the multiple CPU cores.
Multithreading accelerates file compression by allowing a process to be applied to each section of the file simultaneously.
Best Practices for Multithreading in C++
Always utilize thread pools to handle multiple threads and minimize the overhead associated with thread creation.
Within threads, employ std::mutex, std::lock_guard, or std::unique_lock for secure access to shared resources, thus preventing simultaneous access by other threads.
To circumvent deadlocks, acquire locks in a defined order, or if acquiring multiple mutexes, utilize std::lock.
Refrain from busy waiting and instead use condition variables to notify threads.
Employ thread-safe libraries and make sure shared data structures are appropriately synchronized.
Join threads before program termination or detach them for programs meant to function autonomously.
Opt for std::async and std::future for straightforward tasks rather than managing threads manually.
Conclusion
Multithreading enables the development of efficient and concurrent applications by running multiple tasks simultaneously. C++11 offers the std::thread library and synchronization mechanisms, which facilitate safe multithreaded programming. However, it also introduces challenges like deadlocks and race conditions. By comprehending the workings of multithreading, its life cycle, applications, and best practices, you can develop a robust C++ program that leverages multithreading.
Multithreading in C++ – FAQs
Q1. How do I create a thread in C++?
A thread in C++ can be created using the std::thread t(function_name); syntax.
Q2. What is the purpose of join()?
The join() method halts the main thread until the thread that has been joined completes.
Q3. When is it appropriate to use detach()?
Use detach() when it is necessary to allow a thread to run in the background independently.
Q4. How can I safeguard shared data?
You can secure shared data using std::mutex along with std::lock_guard and std::unique_lock in C++ programs.
Q5. When is condition_variable used?
Condition_variable should be employed to pause threads until a specific condition has been satisfied.
To provide the best experiences, we use technologies like cookies to store and/or access device information. Consenting to these technologies will allow us to process data such as browsing behavior or unique IDs on this site. Not consenting or withdrawing consent, may adversely affect certain features and functions.
Functional
Always active
The technical storage or access is strictly necessary for the legitimate purpose of enabling the use of a specific service explicitly requested by the subscriber or user, or for the sole purpose of carrying out the transmission of a communication over an electronic communications network.
Preferences
The technical storage or access is necessary for the legitimate purpose of storing preferences that are not requested by the subscriber or user.
Statistics
The technical storage or access that is used exclusively for statistical purposes.The technical storage or access that is used exclusively for anonymous statistical purposes. Without a subpoena, voluntary compliance on the part of your Internet Service Provider, or additional records from a third party, information stored or retrieved for this purpose alone cannot usually be used to identify you.
Marketing
The technical storage or access is required to create user profiles to send advertising, or to track the user on a website or across several websites for similar marketing purposes.
